1. Java és C++ kapcsolata. 1

2. A Java nyelv jellemzői 2

3. Java fejlesztőeszközök. 3

4. A Java nyelv működése. 4

5. A Java szintaxisa. 5

6. A Java osztályrendszere és csomagrendszere. 6

7. Java Appletek készítése. 8

8. Servletek és JSP-k készítése. 11

         8.1. Servletek. 11

         8.2. JSP – Java Server Pages. 15

9. Java Servletek és Java Appletek kommunikálása. 19

10. Servlet és CGI összehasonlítása. 20

 

A Java programozási nyelv

 

A Java nyelv egy hagyományos értelemben vett programozási nyelv. Pontosabban véve egy objektum orientált programozási nyelv, melyben csak objektum orientáltan lehet programozni. Felmerül a kérdés, hogy ha a Java egy olyan programozási nyelv, mint az összes többi, akkor miben válik ki a többi hasonló programozási nyelv közül. Java-val megoldható az összes hagyományos programozási feladat, viszont ennél többről van szó.

A Java a Világhálóval kapcsolatos problémákat is képes megoldani. Ebben áll a különlegessége, ezért nevezik, joggal, az Internet programozási nyelvének. Az Interneten script nyelvekkel megoldható a feladatok 80%-a, míg Java – val megoldható a fennmaradt 20% is. Kitapasztalható, hogy Javában viszonylag egyszerű alkalmazásokat írni, az Interneten keresztül más gépek felé adatokat továbbítani, dinamikus web oldalakat, felületeket generálni, létrehozni.

 

1. Java és C++ kapcsolata

 

            A Java nyelv erősen támaszkodik a C++ nyelvre. Mindkét nyelv hibrid nyelv, de a Java esetében a tervezők nem látták fontosnak ezt a tulajdonságot, ezért ilyen szempontból csak a minimálist építették a Java – ba, eltérően a C++ - től, ahol biztosítani kellett a C – vel való  kompatibilitást.

Egyes elgondolások szerint a Java idővel átveszi majd a C++ helyét. Egy általánosan elfogadott vélemény az, hogy a C++ és Java eredményessége nem egymást kizáró. Míg a Java sok olyan dolgot mellőz, amely a C++ - ban homályos és nem működik jól, vagy nem objektum orientált, ezáltal könnyebbé téve a fejlesztést, addig a C++ sokkal gyorsabb. A Java megjelenésekor a Java programok futási ideje 20-30 - szor nagyobb volt, mint egy C++ programé. Ez időközben javult, de a két programozási nyelv ilyen szempontból még mindig jelentős eltérést mutat.

            A Java egyik megteremtője, Bill Joy a következőt állította: Java = C++-- (C plus plus minus minus), ezzel azt akarta jellemezni, hogy a C++ nevet annak idején azért választották, mert a C++ egy haladást jelentett a C – hez képest, a megalkotásakor pedig a Java kiszűrte (levonta) a nehéz részeket, így egy egyszerűbb programozási nyelvet hozva létre. Bruce Eckel (az egyik legolvasottabb Java könyv szerzője) viszont ezzel nem éppen ért egyet, a Java ugyanis nem éppen annyira könnyű, mint mondjuk egy script nyelv.

 

2. A Java nyelv jellemzői

 

Egyszerű. A Java egy olyan programozási nyelv, amelynek szintaktikája a C++ mintáját követi. Ez az a nyelv, amellyel ma a legtöbb objektumorientált szoftvert fejlesztő programozó dolgozik. Az egyszerűség és átültethetés miatt a Java - ban nem lehet mutatókat használni, vagy például a többszörös öröklődés csak korlátozott formában használható. Az önálló függvények helyett csak az osztályok metódusai állnak rendelkezésre. Ezen kívül még számos elem megszüntetésével törekedtek az egyszerűségre. A Sun fejlesztői új funkciókkal is gazdagították a nyelvet. A legfigyelemreméltóbb az automatikus szemétgyűjtés (Garbage Collector), ami a memóriát tisztítja meg a felesleges adatoktól, és segít a hibák megelőzésében. A Sun - nak sikerült megőriznie a Java kis méretét, így a magja csupán 40 kilobájt.

Objektumorientált. A Java objektumorientált nyelv. Ez egy olyan fejlesztési módszer amellyel újrafelhasználható osztályok összekapcsolásával hozzuk létre a kívánt alkalmazást.

Biztonságos. A Sun cég nagy figyelmet szentelt a Java biztonságosságára. Mivel a Java Appletek a felhasználó gépén futnak a hálózatról való letöltés után, ezért lényeges, hogy a letöltött kód ne tartalmazzon hibákat és vírusokat. A Java ezt több módszer felhasználásával próbálja biztosítani, amelyek közül az egyik az, hogy az Appletek egy szoftver alapú “virtuális gép”-en futnak, ahol korlátozva vannak az alacsony szintű hardver hozzáférések, hibaforrások kiküszöbölése céljából.

Rendszer-független és hordozható. A Java egyik legnagyobb erősségét az a képessége jelenti, hogy ugyanaz a kód különböző számítógép-platformokon is futtatható. A fejlesztőknek nem kell a már megírt programot minden olyan platformra külön-külön átírni, lefordítani és javítani, amelyen futtatni szeretnék. Bármely gép, amelyen van Java Interpreter (értelmező), képes a Java Appletek futtatására. A Javat nem érdekli, hogy milyen operációs rendszer van a gépen.

Párhuzamosságot támogató. A Java lehetőséget ad arra, hogy a végrehajtás egyszerre több szálon (thread) fusson. Ez rendkívül fontos tulajdonság egy a Világhálót megcélzó programnyelvtől,  mert nagyobb valósidejű teljesítmény érhető el.

            Ingyenes. A Java magja ingyenes. Letölthető az Internet -ről. Sok olyan ingyenes csomag tölthető le az Internetről, melyekben a problémáink megoldásra találnak.

            Programozó barát. Egy Java –t használó programozó nem kell tudja, hogy egyes osztályok implementálása miként van megvalósítva, nem kell bonyolult dokumentációkban keresnie, hogy milyen függvények állnak rendelkezésére. Csupán az általa használd JDK verzió API (Application Programming Interface) –ját kell használja.

 

3. Java fejlesztőeszközök

 

Minden olyan fejlesztői környezet megfelel Java - ban való programozáshoz, amelyik eleget tesz a Sun által kidolgozott szabványnak. A fejlesztőeszközök közötti különbségek árban és kezelésben mutatkoznak. Néhány ismertebb Java fejlesztőkörnyezet:

Sun JDK – A JDK (Java Developer Kit) a programozáshoz szükséges eszközök (Compiler, Interpreter, Debugger, AppletViewer stb.) gyűjteménye, amely tartalmazza a Java -hoz szükséges alapkönyvtárakat és példaprogramokat. Nem rendelkezik fejlesztői környezettel, emiatt némileg nehézkes a használata. A minimális kezelési lehetőségeket kompenzálja a nagy teljesítőképesség, a Java Standard – nak való tökéletes megfelelés, az a tény, hogy ingyen letölthető az Internetről, valamint az, hogy mindig friss verzió áll rendelkezésre.

Visual J++ - Microsoft fejlesztőkörnyezete.

JBuilder – a JBuilder –ben jelen van a nagy teljesítőképesség, Java-standard optimális támogatása, valamint a vizuális fejlesztői környezetet. Könnyen lehet alkalmazásokat fejleszteni, nem kell foglalkozni a rutinos munkával, az igazi nehézségekre, kihívásokra lehet koncentrálni.

A továbbiakban a JDK –t fogom használni, mivel ingyenes és Interneten elérhető. A JDK a következő eszközöket tartalmazza, amelyek a bin könyvtárban lelhetők fel:

 

▪ appletviewer – Applet Viewer – Appleteket futat anélkül, hogy szükség legyen böngészőre.

▪ javac - Java Compiler - A Javában írt programokat bájtkóddá alakítja.

▪ appletviewer - Java AppletViewer - Appletek tesztelésére és futtatására szolgál.

▪ jdb - Java Debugger - Segít megtalálni a programhibákat a Javaban.

▪ javap - Class File Disassembler - Kompilált Java fájlokat visszafejt.

▪ javadoc - Java Documentation Generator – Java dokumentációt lehet készíteni egy Java forrás állományból, ha a programozó bizonyos szabályokat betart a Java kód szerzésekor.

▪ javah - C Header and Stub File Generator - segítségével natív metódusokat csatolhatunk a Java kódhoz.

▪ jar - Java Archive Tool - Java osztályfájlokat és más forrásokat egy jar archív fájllá.

▪ keytool - Digital Signing Tool – digitális aláírásokat készít.

 

Ezeken az eszközökön kívül az illető könyvtárban még vannak más eszközök is. Ezeknek a használatára nem lesz szükség.

 

4. A Java nyelv működése

 

A programozók a Java segítségével önálló programokat írhatnak, amelyek C++ nyelven programozók programjaihoz hasonlítanak, továbbá olyan Appleteket is készíthetnek, amelyek egy böngészőn belül futtathatók. A legtöbb Java kód, böngészőben futtatható Applet, és nem önálló program. Web alkalmazás szempontjából az Applet a Java által nyújtott lehetőség a kliens oldali programozás megvalósítására. A szerver oldali programozás szempontjából a Java által nyújtott lehetőség a Servlet/JSP technológia használata, amelyek egy Servlet konténerben futnak.

Appletek. Az applet egy kis alkalmazás, ami alatt a következőt kell érteni: az Appletek nem önálló programok, hanem mindig egy meghatározott környezetet igényelnek, amiben képesek létezni és végrehajtódni. Ezt a környezetet a WWW böngészők jelentik, amelyeknek természetesen „Java-képesnek” (Java Enabled) kell lenniük. Minden böngésző, amelyet ma használunk képes Appleteket futatni, csak be kell állítani. Ha egy Web dokumentumba egy Appletet szeretnénk beágyazni, akkor egy hivatkozást kell elhelyeznünk a HTML dokumentumban az Appletre. Ha egy felhasználó ezek után kapcsolatba lép a weboldallal, akkor a böngésző először magát az oldalt tölti le, majd amikor a felhasználó arra a helyre jut, ahol az Appletnek meg kell jelennie, a böngésző automatikusan végrehajtja azt. A dokumentum olvasóinak az Applet úgy jelenik meg, mint az oldal szerves része, így nekik - bizonyos körülmények között – egyáltalán nem tűnik fel, hogy a háttérben épp egy program fut.

Alkalmazások. Ellentétben az Appletekkel, az alkalmazások teljes értékű önálló programok, amelyek végrehajtásához nincs szükség böngészőre vagy más speciális környezetre (leszámítva a Java-értelmezőt). Az önálló programok futtatásához a Java Interpreter - ét kell használni, ez egy olyan speciális program, amely a Java virtuális kódját processzor-specifikus bináris utasításokká fordítja. Az így futtatott alkalmazásoknak olyan képességeik vannak, amelyekkel az Appletek nem rendelkeznek (például fájlműveleteket tudnak végezni).

            Servletek. A Servletek azok a szerver oldali Java osztályok, amelyek dinamikus tartalmú HTML oldalakat generálnak. A Servletek, amint már említettem, egy konténerben, meghajtóban (Engine) futnak. Ez a Sun előírásainak meg kell feleljen. Egy „minta” konténer a Tomcat. Ezen kívül léteznek más hasonló konténerek is, mint például JBoss, Bea stb. Viszont ezek is be kell tartsák az említett előírásokat, attól még különböznek egymástól a szolgáltatott osztályokban s a nyújtott megoldásokban. A konténer kapcsolatban áll a webszerverrel. Abban a pillanatban amikor a webszerver egy dinamikus forrásra való kérést kap, átadja ezt a konténernek, amelyik ha megtalálja az illető osztályt generálja a kért oldalt.

 

5. A Java szintaxisa

 

A Java sok területen eltávolodott a régismert programnyelvektől, viszont bizonyos tulajdonságaiban a C-t és a C++-t követi. Minden programozási nyelvnek megvan a saját „nyelvezete”, szintaxisa. A szintaxis ismerete egy nélkülözhetetlen lépés a programozási nyelv elsajátításában valamint ennek a használatában. A következő elemek vannak jelen a Java szintaxisában:

Azonosítók. Változóknak, osztályoknak és metódusoknak adott elnevezések. Célszerű az azonosítóknak egyszerű, mégis jellemző nevet adni. A kérdés már csak az, hogy ez legyen angolul vagy minden programozó a saját nyelvén írja meg. Ha a programozó azt akarja elérni, hogy bárki tudja használni metódusait, akkor célszerű angolul megnevezni az osztályokat. Az osztályok neveit szokás nagybetűvel kezdeni és kisbetűkkel folytatni. A több szóból álló neveknél az egyes szavak kezdőbetűit nagybetűvel írjuk (pl. getElementCount() ). A változók neve általában kis betűvel kezdődik. Fontos megjegyezni, hogy ezek csak egyezmények, viszont a legtöbben ezeket betartják, mert átláthatóbbá válik a forráskód. Ideje megemlíteni, hogy Java-ban különbség van a kis és nagybetűk között, más karaktereket is lehet használni mint amiket az angol ábécé biztosít, így például ékezetes azonosítókat.

Kulcsszavak. A Java nyelv által lefoglalt azonosítók. A lefoglalt kulcsszavak nem használhatók a programozó által azonosítóként (pl. for, while, do, repeat, implements, extends stb.).

Típus rendszer. A „Java-ban minden objektum” kifejezés csak részben igaz, mivel jelen vannak a „primitív” típusok, úgy mint C-ben. Ezek a következők: boolean, char, byte, short, int, long, float, double, void. Mindezeknek viszont megfelel egy-egy Java osztály, mely az adott értéken kívül még különböző hasznos metódusokat is tartalmaz az adott típussal való műveletekre. Tehát létezik egy Boolean, Character, Byte, Short, Integer, Long, Float, Double, Void osztály. A primitív típusok a veremben tárolódnak, míg az objektumok a heap - ben. Ez fontos különbség, mivel a művelet gyorsabban végrehajtódik egy primitív típus esetében.

Operátorok, műveletek. Elemi számítási műveleteket végezhetünk velük. Az objektumok esetében bizonyos operátorok működnek, de nem az elvárt eredményt szolgáltatják. Kivétel erre a String objektum, egyetlen objektum a Java-ban, melyre létezik a C++ - ban gyakran használt operátor-túlterhelés.

Elválasztó jelek. A forráskód szerkesztésekor használhatók. Fontosabb szeparátorok: (),{},;. A Java hasonlóan a többi programnyelvhez megengedi a megjegyzések elhelyezését a forráskódban. Két féle megjegyzés lehetséges: „//” – vel kezdődő magyarázat a sor végéig tart, a „/* magyarázat */” esetben a magyarázat több soros is lehet. A bizonyos szabályokat betartó magyarázatból dokumentációt lehet készíteni (a javadoc.exe segítségével), ezáltal a Java egybehangolja a kódolást a dokumentálással.

Vezérlési struktúrák. A Java vezérlési szerkezetei a már jól bevált C-s szintaxisra épülnek, így ezeket külön nem látom értelmét részletezni.

 

6. A Java osztályrendszere és csomagrendszere

 

A feljebb említett kivételen kívül Java –ban minden objektum. Mindennek ellenére a programozó csupán az objektumnak csupán egy handle – jával dolgozik. Megeshet az is,  hogy egy handle nem mutat egy objektumra, mivel nem volt inicializálva. Ezt egy hasonlattal lehet szemléltetni: a távirányító is létezhet tévé nélkül, csak akkor nincs mit irányítsunk vele, ezért, mielőtt használnánk minden egyes objektumot létre kell hozni.

A Java-ban léteznek interfacek, abstract osztályok, és osztályok. Az interface csupán az adattagok és metódusok neveit tartalmazza. Az abstract osztály hasonlóan az interface-hez tartalmaz bizonyos metódusokat és adattagokat, ezen kívül tartalmazhat implementálást is. Az osztályok minden egyes metódusra kell tartalmazzanak implementálást.

Minden egyes osztály egy közös őstől származik, a C++ - tól eltérően. Ha az osztály létrehozásakor nem akarunk sehonnan se örököltetni, akkor az illető osztály a java.lang.Object osztályból öröklődik. A többszörös öröklés ki van zárva, viszont lehetséges egy olyan öröklődés, mely egy ős osztályból származik, s még néhány interfacetől is örökölhet.

Az objektumok létrehozásáról tehát a programozó kell gondoskodjon, a memória felszabadításáról viszont nem. Létezik egy Garbage Colletor, ami elvégzi a memória felszabadítását, amikor arra szükség van, azáltal, hogy a már nem használt objektumoknak lefoglalt memóriát üríti. Nem hagyja, hogy a memória „megteljen”, hanem bizonyos pillanatokban kiüríti a memóriában levő, már nem használható objektumokat.

            A Java osztályai csomagokba (package) vannak szervezve. Egy csomagba több osztály tartozik. Például az Applet osztály csomagjának neve: java.applet, az osztály pedig java.applet.Applet. A forráskód elején az import kulcsszóval importálhatunk ilyen csomagokat, utána pedig a csomag egész tartalma látható lesz a programban, csak az osztály nevét kell majd használni (pl. Applet). Ennek célja egyrészt a rendszerezés, másrészt pedig a névkonfliktusok elkerülése, amely lehetővé teszi, hogy létezzen két, vagy több azonos nevű osztály, viszont különböző csomagokban. Egy csomaghoz való tartozás a package kulcsszóval adható meg. Ha ez a hozzárendelés hiányzik, akkor az illető osztály a default csomagba fog tartozni.

Könnyen előfordulhat a következő esett: két programozó azonos nevet add az osztálynak, valamint a csomagnak is, ekkor felléphet a nem kívánatos névkonfliktus. A Java által nyújtott megoldás egy egyezmény: mindenkinek a domain nevét kell használnia csomagjainak elnevezéseiben, fordított sorrendben, mivel ezekre biztosított, hogy egyediek. Például az én domain nevem sziszu.uni.cc. Ez azt jelenti, hogy Java csomagom neve a cc.uni.sziszu lesz.

A legalapvetőbb, s tehát legfontosabb csomagok a következők:

 

▪ java.applet: Appletek készítésére használatos osztályokat tartalmaz.

▪ java.awt: az ablakozó rendszert tartalmazza (Abstract Windowing Toolkit).

▪ java.awt.image és java.awt.peer: AWT segéd osztályait tartalmazza.

▪ java.io a be- és kiviteli műveletekhez szükséges osztályokat.

▪ java.lang a nyelvi szinten definiált osztályokat.

▪ java.net a hálózatkezelésért van.

▪ java.util a segédosztályokat tartalmazza.

 

7. Java Appletek készítése

 

Egy Java Applet fordítása, futtatása

Egy Java Applet elkészítéséhez az Applet osztályból kell leszármaztatni az elkészíteni kívánt osztályt, majd bizonyos osztályokat implementálni kell, vagy felülírni. Az Applet osztály a JDK1.4. API – ban a következő hierarchia része:

▪ java.lang.Object

   |

  +--java.awt.Component

         |

        +--java.awt.Container

               |

              +--java.awt.Panel

                     |

                    +--java.applet.Applet

 

Az állomány kiterjesztése java kell legyen, bármilyen szövegszerkesztőben dolgozhatunk. Az állomány neve és a benne levő public osztály neve meg kell, hogy egyezzen. Általában minden osztály külön állományban kell szerepeljen, de nem kötelező; az átláthatóság miatt használatos ez a módszer. Ha valaki úgy dönt, hogy több osztály kódját menti le egyetlen állományba, akkor azzal számolnia kell, hogy közülük csak egy lehet public, azaz bárhonnan látható.

A Java programutasítások virtuális gépi kóddá történő alakításához a forrásfájlt egy speciális programmal, a Java fordítóprogrammal le kell fordítanunk. A JDK tartalmazza ezt a fordítóprogramot, amit MS-DOS parancssorból tudunk indítani, például a következő módon:

▪ C:\Temp\Serv\JDK4\bin>javac AppletProba.java

A fenti parancssor hatására, ha nincsenek hibák a forráskódban, akkor a fordítóprogram lefordítja az AppletProba.java forrásfájlt. Újra megemlítem, hogy a Java különbséget tesz a kis- és nagybetűk között. Ha a fordító sikeresen elvégezte feladatát, akkor a forrásfájlból készít egy ún. virtuális gépi kódú fájlt. Ennek a fájlnak a kiterjesztése .class, a neve pedig megegyezik a forrásfájl nevével (ez esetben AppletProba.class). Az appletnek ez a class fájlja tartalmazza a virtuális gépi kódot, amelyet egy Appletnéző (appletviewer.exe) vagy egy böngésző már végre tud hajtani. A HTML oldal forrásszövegébe a következőt kell beírni:

▪ <applet code=”AppletProba.class” width=”400” height=”400”> </applet>

 

Speciális függvények

A programozó ahhoz, hogy Appletet készítsen néhány metódust kell átírjon (override). Ezek a következő táblázatban szerepelnek:

 

Metódus	Használat
init()	Az Applet minden egyes indításakor meghívja ezt a függvényt.
start()	Az init() után hívódik meg először. Akárhányszor előtérbe kerül a HTML oldalon, meghívódik.
paint()	A Component ősosztály része.
stop()	Mindannyiszor meghívódik, ahányszor az Applet a weboldalon eltűnik a látható részből. A destroy() előtt hívódik  meg utoljára.
destroy()	Akkor hívódik meg, amikor az Applet kitöltődik az Web oldalból.

 

Az init() függvény. Nem kötelező ennek a függvénynek a felülírása, egyszerű Appleteknél nem is szükséges. Ha valamilyen kezdőértéket szeretnénk adni, akkor ez alkalmas hely. Ilyen kezdőértékek: a betű típus, betű méret, képfájlok, hangfájlok stb. Ugyanebben a függvényben lehet „feltűzdelni” az Appletre a különböző komponenseket az add() függvény segítségével.

A start() függvény. Miután az Applet futtatta az init függvényt, meghív egy speciális, start nevű függvényt, aminek az a rendeltetése, hogy elindítsa az Applet végrehajtását. A legtöbb Appletben a start() függvény létrehoz egy vagy több végrehajtási szálat, amelyek végrehajtják az Appletet.

A stop() függvény. Amikor az Applet befejeződik, az Applet meghívja a stop függvényt. A böngészőktől és az Appletet tartalmazó weboldal tartalmától függően előfordulhat, hogy a böngésző leállítja az Appletet, amikor az Applet eltűnik a látómezőből. Ilyenkor is a stop() függvény hívódik meg, majd mikor ismét a látómezőbe kerül, akkor a start() függvény.

A paint() függvény. Minden alkalommal, mikor a böngészőnek frissítenie kell az Applet ablakát, a böngésző meghívja a paint() függvényt. Ezen a függvényen belül kell az Applet minden olyan elemét újrarajzolni, amit már korábban megjelenített az ablakban. Az Applet által végzett művelettől függően lehetnek olyan esetek, mikor saját magának kell újrarajzolnia ablakát, ilyenkor az Applet meghívja a repaint() függvényt, ami viszont a maga részéről meghívja a paint() függvényt.

A destroy() függvény. Mint már volt róla szó, a Java az init() függvény segítségével teszi lehetővé, hogy kezdeti értékeket adjunk a legfontosabb változóinknak. A Java a destroy függvény által arra is lehetőséget ad, hogy megszabaduljunk az objektumoktól. Ez a függvény a C++ destruktor függvényeihez hasonlóan teszi lehetővé az erőforrások felszabadítását. Általában ezt nem használják a programozók, mert a Java tud gondoskodni az „elhalt” objektumokról kellő időben.

 

Paraméterek átadása Appletnek

Az Applet értelme, hogy beépítsük egy HTML dokumentumba. Egy elkészített Applet több dokumentumba is beépíthető. Ez azt jelenti, hogy megtörténhet például, hogy egyik ilyen oldal háttere bizonyos színű, egy másiké pedig ettől igen eltérő. Ekkor jó lenne, ha az Appletnek mindkét esetben olyan háttérszínt lehetne biztosítani, amely megfelel, és nem zavarja a weblap színét. Ezen kívül megeshet, hogy más betűtípust, betűszínt, betűméretet szeretnénk biztosítani a különböző oldalak esetében. Erre a megoldás egyszerű, paramétereket lehet használni.

A HTML nyelv erre lehetőséget nyújt. Ezt az <applet> és </applet> elemek között elhelyezett <param> tag segítségével lehet elvégezni:

▪ <applet code=AppletProba.class width=400 height=200>

▪ <param name=szovegtipus value=”Arial”>

▪ <param name=betumeret value=”12”></applet>

Az Appleten belül az init() függvényben, egy függvény segítségével tudjuk lekérdezni az átadott paramétereket következő módon:

▪ String Parameter1 = getParameter(“szovegtipus”);

▪ String Parameter2 = getParameter(“betumeret”);

 

Egéresemények kezelése

A Java appletek sikerének egyik legfontosabb tényezője, hogy appletek lehetővé teszik a felhasználó közreműködését. Grafikus környezetben a felhasználó legtöbbször egérműveletekkel tud valamely folyamatban közreműködni, így a közreműködés gyors és eredményes. Ez azt jelenti, hogy az Applet olyan funkcionalitásokkal tud felruházni egy oldalt, amely hasonló lesz bármely olyan programhoz mely egy fejlett vizuális felülettel rendelkezik, azaz egy olyan termékhez melyet VB-ben, Delphi-ben volt megírva.

Az egéresemények kezelésérre a Java – ban két módszer van. A legújabbat, legeredményesebbet ismertetem a továbbiakban. Ahhoz, hogy ezt megtehessük az Appleten  belül egy belső osztályt kell deklaráljunk, amely a java.awt.event.MouseListener inteface-t implementálja. Ehhez öt metódust kell megírni: mouseClicked(MouseEvent e),  mousePressed(MouseEvent e), mouseReleased(MouseEvent e), mouseEntered(MouseEvent e), mouseExited(MouseEvent e). Ha valamelyik metódus nem érdekel, annak belsejébe nem írunk semmit. A következő lépés: az Applet init() metódusában meghívjuk az addMouseListener(new Kattintas()), abban az esetben ha a deklarált osztályt Kattintas –nak neveztük el. Ezek után bármit szeretnénk, hogy történjen az  adott kattintásra, megtehetjük ha beírjuk az illető kódot a megfelelő metódusba.

 

Billentyűesemények kezelése

            Egy másik fontos esemény a billentyűkkel kapcsolatos események. Három ilyen esemény lehetséges: lenyomtuk a billentyűt, elengedtünk a billentyűt, valamint ezek együttese. Gyakran ezekre az eseményekre is szüksége van egy programozónak.

            Az egéreseményekhez hasonlóan a billentyűeseményeket is hasonló módon kell kezelni. A különbség az, hogy a java.awt.event.KeyListener inteface-t kell implementálni, tulajdonképpen ennek három metódusát: keyPressed(KeyEvent e), keyReleased(KeyEvent e), keyTyped(KeyEvent e). Ha az implementált osztály neve Billentyuz, akkor meghívjuk az Applet osztály addMouseListener(new Billentyuz()) metódusát.

A két féle eseményt nemcsak Appletre lehet használni. Minden egyes komponens esetében az eljárás hasonló, azzal az egyetlen különbséggel, hogy az illető komponens metódusait kell meghívnunk a bemutatott módon. A komponensek más programozási nyelvek komponenseihez hasonlítanak: Button, TextArea, Label, Canvas, CheckBox, List, Choice stb.

 

8. Servletek és JSP-k készítése

 

8.1. Servletek

 

Egy Servlet fordítása, futtatása

Egy web alkalmazás Servletjeit a HttpServlet osztályból kell leszármaztatni. Ez az osztály a servlet.jar csomagban található, akárcsak a többi Servlettel kapcsolatos osztály. Ennek az osztálynak a hierarchiája:

▪ java.lang.Object

   |

  +-- javax.servlet.GenericServlet

         |

        +-- javax.servlet.http.HttpServlet

 

Fordítás után a Servlet konténer már képes használni az osztályt. Ezek az Appleteknél említett módon történik. Az osztály a Web-inf/classes könyvtárba kell kerüljön. A Web-inf könyvtár tartalma nem érhető el közvetlenül. Amikor mindez megtörtént, az osztály bármely böngészőből elérhető a következő módon, feltételezve, hogy a lefordított osztály neve ServletProba.class, valamint hogy a szerver neve www.hirportal.com:

▪ http://www.hirportal.com/servlet/ServletProba

 

Speciális függvények

Ugyancsak az Appletekhez hasonlóan, a Servlet osztály leszármaztatása után bizonyos metódusokat kell átírni, ahhoz, hogy a Servlet a programozó által kívánt műveleteket létre tudja hozni. A legfontosabbak ezek közül a következők:

 

Metódus	Használat
init()	A Servlet élettartalmára vonatkozó források kezelésére alkalmas, valamint kezdőértékesítésre. Általában adatbázis kapcsolat kiépítésére használható.
destroy()	Az illető Servlet objektum elhalálozásakor bizonyos erőforrások felszabadítására használatos.
doGet()	A kliens Http Get kérésének feldolgozása.
doDelete()	A kliens Http Delete kérésének feldolgozása.
doPost()	A kliens Http Post kérésének feldolgozása.
doPut()	A kliens Http Put kérésének feldolgozása.

 

CGI változók

A CGI-vel való kompatibilitás fenntartásának érdekében a Java Servlet osztályok tartalmazzák az összes CGI változóhoz való hozzáférést megvalósító eszközöket. Egyes esetekben ezeknek a használata fölösleges, mivel a Servlet és a Web Szerver között megvalósítható olyan kommunikáció amely a CGI-k esetében nem volt megvalósítható. A következő táblázatban a request a Servlet HttpServletRequest paraméterének a neve.

 

CGI változókhoz való hozzáférés Servletből

 

Paraméterek átadása Servletnek

A Servlet megírásához felül kell írni egyiket az említett függvények közül. A legegyszerűbb, ha a doGet (HttpServletRequest request, HttpServletResponse response) metódust használjuk, ennek a kérése egy böngészőből a legegyszerűbben megvalósítható. Csupán be kell írnunk a következőt:

▪ http://www.hirportal.com/servlet/ServletProba?param1=elso&param2=2.

Ekkor a ServletProba Servletnek átadtunk két paramétert: param1 melynek értéke „elso”, és  param2 melynek értéke „2”. A Servletben az illető paraméterek a következő képen érhetők el: a doGet metódus testében meghívjuk a request paraméter getParameter() metódusát:

▪ String Parameter1 = request.getParameter(“param1”);

▪ String Parameter2 = request.getParameter(“param2”);

Észrevehető, hogy mennyire hasonlít az Appletek és Servletek paraméterlekérdezése.

 

Servlet  szolgáltatta HTML oldal

A Servlet lényege, hogy bizonyos műveletek elvégzése után eredményül egy HTML oldalt szolgáltasson. Ennek megvalósítása érdekében a feljebb említett response paraméter néhány metódusát kell használni, a doGet metódus testében:

▪ response.setContentType("TEXT/HTML");

▪ PrintWriter out = response.getWriter();

▪ out.println("<HTML><HEAD><TITLE>Cím</TITLE></HEAD>");

▪ out.println("<BODY>Szöveg</BODY></HTML>");

 

Első lépésként a válasz objektumban (response) be kell állítani a szolgáltatott oldal tartalmát, mely a legtöbb esetben szöveg. Ezekben az esetekben mindig TEXT/HTML paramétert kell használni. A továbbiakban le kell kérni azt az objektumot, melybe írni lehet. Miután ennek az objektumnak a kezelőjét (handler) out-al neveztük el, használhatjuk a print() vagy println() metódusait, ahogyan feljebb. Egy HTML oldalt generálunk, ezért fontosak a tag-ek használata a visszatérített szöveg megformázására, táblázatok felépítésére stb.

Hasonló képen lehet XML oldalakat generálni, azzal a különbséggel, hogy XML tag- eket kell használni, valamint a tartalom beállításánál is jelezni kell, hogy milyen oldalról van szó. Mindezek mellett az XML állományok megszerkesztése több figyelmet követel, nem olyan egyszerűek mint a HTML oldalak. A legtöbb böngésző (az IE és Netscape esetekben kipróbáltam) képes feldolgozni az XML oldalakat is.

 

HttpSession

A HTTPSession objektumokat azért vezették be, hogy a Servletek segítségével meg lehessen valósítani egy „statefull” kapcsolatot a kliens és a Szerver között. Formálisan egy HTTPSession objektum képes információk megőrzésére két kérés között. A feltétel az, hogy a két kérés ugyanattól a klienstől jöjjön, anélkül, hogy a kliens alkalmazást lelett volna zárva. Gyakorlatban: ha elindítunk egy böngészőt és egy kérést intézünk egy Web Szerverhez, megkapjuk a választ, és anélkül, hogy újraindítanánk a böngészőt ismét kérést intézünk a szerverhez, a HTTPSession objektum képes megjegyezni, hogy azelőtt is tőlünk jött a kérés.

Erre azért volt szükség, mivel a HTTP protokoll nyújtotta kommunikálás annyit valósít meg, hogy egy kérést küld, majd erre kap egy választ. Ennek az előnye az egyszerűség, hátrányát pedig egy példával szemléltetem: például egy azonosítást igénylő kérést küldünk egy Szervernek, azonosítjuk magunkat megfelelő felhasználó névvel és jelszóval. Ha ezek után egy másik olyan kérést akarnánk intézni a Szerverhez, amelyik azonosítást igényel, akkor ismét meg kellene adni a jelszót. Ennek elkerülése végett vezették be a HTTPSession objektumot a Servleteknél.

Az említett információk a szerver oldalon vannak megőrizve a következő alakban: (név, objetkum). Egy HTTPSession objektum többek között a következőket tudja végrehajtani:

▪ meg tudja mondani ha egy objektum új vagy rési (isNew() metódus segítségével),

▪ objektumokat lehet elhelyezni, bizonyos nevet szolgáltatva (setAttribute() metódus),

▪ az elhelyezett objektumokat le lehet kérni nevük segítségével (getAttribute() metódus)

 

A következő módszerekkel lehet megvalósítani a „statefull” kapcsolatot a Szerver és Kliens között:

▪ Egy Cookie mechanizmus kiépítése minden egyes klienssel. Ez abban áll, hogy a Kliens részen a merevlemezen őrződnek meg bizonyos információk, amelyek el lesznek küldve a HTTP kéréssel.

▪ Egy szimulálásnak nevezett módszerrel, amely úgy valósítható meg, hogy a kliens részen tárolunk bizonyos adatokat: <input type=”hidden” name=”session” value=”...”>. Ezek az információk elérnek a Szerverhez amelyik fel tudja dolgozni őket.

▪ Az URL –be írt bizonyos információk.

▪ A bemutatott HTTPSession objektumok segítségével, Szerver oldalon.

 

8.2. JSP – Java Server Pages

 

JSP oldal írása

Java Server Pages egy olyan technológia amely használatával megvalósítható, hogy egy osztott Web alkalmazás esetében a Szerver és Kliens rész egy állományban legyen tárolva. Tehát a statikus rész és a dinamikus rész ugyanabban az állományban lesznek tárolva, melynek nevében a jsp kiterjesztésnek kell szerepelnie. A statikus rész megfelel a HTML vagy XML nyelv elemeinek. A dinamikus részek ugyanebben az állományban vannak szétosztva, a dinamikus elemek a megfelelő helyeken szerepelnek. A dinamikus részek szétválasztása különleges tag-ek segítségével történik, amelyek a következő elemeket tartalmazzák: <%...%> vagy <jsp:...>. Nem a JSP az egyetlen ilyen technológia. Ugyanígy működnek az ASP és PHP technológiák is.

 

JSP oldalak működése

A jsp kiterjesztésű állományok a statikus HTML oldalakkal egy könyvtárban kell legyenek. Például ha a JSPProba.jsp állomány a ROOT könyvtárban van, akkor ennek elérése:

▪ http://www.hirportal.com/JSPProba.jsp

            Megjegyezendő, hogy a jsp állományokat nem szabad a Servletek könyvtárába tenni, mert akkor nem lesznek elérhetők. A fenti oldal lekérésének az esetében a statikus elemek változatlanul maradnak, míg a dinamikus részek helyébe bekerül a generált rész. Így a felhasználó egészében statikus honlapot lát.

            Tulajdonképpen a JSP oldal is egy Servlet lesz, mielőtt elvégzi a reá háruló műveleteket. Az első lekérésnél a konténer generál egy neki megfelelő class kiterjesztésű Java osztályt. A felhasználónak szolgáltatott oldalt tulajdonképpen ez a Servlet generálja. Felmerülhet a kérdés, miért volt szükség erre a technológiára. A válasz az, hogy sokkal könnyebb a statikus részek közé beszúrni a dinamikus részeket, minthogy egy Servletből írogassuk ki a statikus részt a println() metódussal.

 

Előredefiniált objektumok

Ahhoz, hogy minél egyszerűbben lehessen megírni a dinamikus részhez tartozó kódot, a JSP-ben vannak előre definiált objektumok. Ezek a következők: request, response, out, session, application, config, pageContext, page, exception. Ezeken anélkül lehet használni, hogy deklaráltuk volna. Ezek a legfontosabb objektumok egy JSP írásakor. Megeshet, hogy egy JSP írásakor nincs szükségünk ezekre.

request – a HttpServletRequest osztály objektuma, magába foglalja a kérés paramétereit. Ezeket a Servleteknél említett módon lehet megkapni a request.getParameter() metódussal. Ezek a paraméterek többfélék lehetnek, attól függően, hogy milyen kéréssel volt meghívva a Servlet. Ugyancsak a Servletekhez hasonlóan a programozó lekérheti a kéréshez tartozó Cookie-at (request.getCookies()) és a kéréshez tartozó HTTPSession objektumot (request.getSession(true)). Az utóbbinak a használata legtöbbször fölösleges, mivel van egy előredeklarált session objektum.

response – a HttpServletResponse osztály objektuma, amely magába foglalja a kliensnek szánt választ megvalósító metódusokat és változókat. Ennek a használata azonos a  Servleteknél használttal. A response.addCookie() – val lehet Cookie –at hozzáadni a válasz objektumhoz, melyet a kliens böngészője majd feldolgoz. Ez a metódus használható sime Servleteknél is.

out – a JSPWriter osztály objektuma, melyen keresztül bináris adatokat lehet küldeni a kliensnek. A JSP kifejezések egyenesen ide írják dinamikus tartalmukat. Ritkán kerülhet arra sor, hogy ezt az objektumot a programozó közvetlenül is használja.

session – a HttpSession osztály objektuma, melyet a  request.getSession(true) metódus meghívásával lehet megkapni. Ez teljesen megegyezik a Servlet résznél tárgyalt HTTPSession-nal. Közvetlenül el lehet érni, kivéve akkor, hogy ha a false értékkel volt paraméterezve. A true (vagy false) boolean paraméter arra vonatkozik, hogy ha használatkor nem létezik a kéréshez tulajdonított HTTPSession objektum, akkor hozza létre automatikusan vagy nem. Abban az esetben ha nem akarjuk, hogy létrehozza, akkor természetes, hogy nem tudjuk használni, mivel az objektum null, azaz nem mutat sehova a heapben.

application – a ServletContext osztály objektuma (getServletConfig().getContext()). Az alkalmazás egész élettartalma alatt elérhető, azaz az összes Servletnek egy ilyen objektuma van, míg az eddig tárgyalt objektumok esetében minden Servletnek külön-külön megvoltak. Ez az objektum úgy viselkedik, mint egy objektum „tároló”. Objektumokat lehet raktározni benne, amelyek kapcsolatot biztosítanak a Servletek között. Ez a setAttribute(String nev, Object objektum) metódussal valósítható meg. A getAttribute(String nev) metódussal pedig le lehet kérni amegadott névhez kapcsolodó objektumot. A removeAttribute(String nev) metódus kitörli az adott névvel rendelkező objektumot.

page – a jelenlegi JSP objektummal azonos, a this kulcsszóval ugyanazt a hatás érhető el. Alapjában véve azért iktatták be az előre definiált objektumok közé, hogy ha megjelennek más script nyelvek is, akkor némileg legyen kompatibilis azokkal.

Config – a ServletConfig osztály objektuma. A Servlet inicializálásának idejében lehet használni (a Servleteknél említett init() metódusban).

pageContext – a PageContext osztály objektuma, melyet a JSP vezet be, ez nem található meg a Servleteknél. Ez az objektum tükrözi egy adott időben az oldal állapotát. Fontosabb metódusai: removeAttribute(), setAttribute(), getAttribute(), findAttribute() stb.

exception –  java.lang.Throwable osztály objektuma, amely akkor jelentkezik, amikor az oldal hibásan van meghívva.

 

JavaBeans

A JavaBeans API megengedi komponensek használatát Java -ban. Egy komponens egy software egység amely „újrahasználható”, amelyet vizuálisan lehet kezelni különböző eszközökkel. A Java komponenseket bean –eknek nevezik. Ezek hasonlóak a Delphi és VB komponenseihez.

A Bean –eket három területen használják:

▪ Vizuális komponensek, amelyet a GUI (Graphical User Interface) egyszerűsítésére használnak a kliens oldalon. Ezeket bizonyos BeanBuilder csomagok kezelik, amelyek segítik a programozót a Beanek létrehozásában, tesztelésében és felhasználásában.

▪ EJB típusú komponensek (Enterprise Java Beans). Komplex Web alkalmazások nélkülözhetetlen része, az úgynevezett bussines részt valósítják meg EJB -kel (J2EE). Egy konténerben (szerverben) élnek.

▪ JSP oldalakban használt komponensek, legfőbbképpen a JSP oldalak kódolásának könnyítésére használatosak.

 

Legegyszerűbben fogalmazva, a JSP oldalakban használt komponens  kell tartalmazzon egy paraméter nélküli konstruktort, a metódusai private adattagokkal kell dolgozzanak, amelyeket getter és setter metódusokon keresztül lehet elérni. Például:

▪ private String nev;

▪ public void setNev(String ujNev) {…}

▪ public String getNev() {…}

▪ public boolean isNev() {...} //boolean esetén, get helyett is

 

A komponensek használata nagyon fontos, mivel lehetővé teszi az újrahasználható osztályok lehetőségeinek kiaknázását. Ezen kívül lehetővé válik a forrás kód újrahasznosítása is. A JSP oldalak egyszerűbbé válnak azáltal, hogy nem kell kódot írni, hanem csak meghívjuk a Bean bizonyos metódusát. Egy – egy Bean – t fel lehet használni több JSP oldalnál is. A Bean –ek eredményes használata érdekében fontos az alkalmazás megfelelő tervezése.

 

JSP szintaxis

            A következő táblázatban össze vannak foglalva az összes JSP szintaxis elemek. Ezek használata nélkülözhetetlen a JSP szerkesztésében.

 

 

 

9. Java Servletek és Java Appletek kommunikálása

 

Egy Applet képes bármilyen szerver oldali programozási módszerrel fenntartani a kapcsolatot, az URLConnection objektumon keresztül. Így tehát képes kommunikálni CGI –kkel, PHP –vel, ASP –vel, stb. Ez úgy történik, mintha a böngésző küldene egy GET kérést a szervernek. Ezek után minden úgy történik, mint a böngésző esetében, azzal a különbséggel, hogy az Applet átveszi a böngésző szerepét. Így tehát ezzel a módszerrel kapcsolatba léphet egy Servlettel is.

            Amint az várható is volt a kliens részen működő Applet és a Servlet oldalon futó Servlet között speciális kapcsolat alakítható ki. Ez azt jelenti, hogy az előbbi módszeren keresztül még létezik egy módszer, amelyen keresztül a két Java rész egymással kapcsolatba léphet. Kettőjük között kiépíthető egy kommunikációs csatorna, amelyen keresztül Java objektumokat lehet cserélni. Ez az ObjectInputStream és ObjectOutputStream osztályokkal valósítható meg.

            Természetes módon itt sem valósítható meg egy folytonos kapcsolat a Szerver és a Kliens között, mivel a használt protokoll a HTTP protokoll. Ennek a megkötéseiről már volt szó. Az objektum csere esetében is fennáll az, hogy egyszerre egy kérést lehet küldeni, erre pedig egy választ, ebben az esetben egy objektumot lehet kapni. Ha több ilyen cserét akarunk megvalósítani, akkor ezt több kérésen keresztül lehet megvalósítani.

            A Servlet és Applet közötti kommunikációt legjobban XML segítségével érdemes megvalósítani. Ezt azért érdemes, mert az XML egyrészt rendszerezi az adatokat, másrészt pedig platform függetlenül tud adatokat ábrázolni. Az XML adatokkal való műveletek megvalósítására a Java XML API –t lehet használni. Ez azt jelenti, hogy kiépíthetők komplex Web alkalmazások csupán Java és XML segítségével.

Példát erre a kapcsolatra, mint a többi említett JSP, Servlet, Applet, Bean érdekességekre is az alkalmazás részben lehet találni.

 

 

10. Servlet és CGI összehasonlítása

 

A Java Servlet technológia használata Web programozás esetén a következő okok miatt előnyösebb mint a klasszikus CGI –k használata:

▪ Eredményesség: CGI esetén minden egyes kérésre a Web server egy külön folyamatot indít, emiatt sok kérés esetén a Szerver válasz ideje igen nagy lehet. A Servletek esetében a JVM csak egy új futási szállat indít (egy új thread –et indít), ez kevesebb erőforrást igényel.

▪ Tervezés: Egy CGI megtervezése és fejlesztése Perl –ben vagy C –ben nagy számú megkötés betartását igényli, ami nagy mértékben nehezíti a fejlesztést. A Servleteknél a megkötések a Java nyelv megkötései, azaz, aki ismeri a Java nyelvet annak semmilyen gondja nincs egy Servlet megírásánál. Bármilyen Java alkalmazás tervezése elég egyszerű, ha ki vannak használva az objektum orientált paradigma lehetőségei.

▪ Hatalom: A Servletek könnyen kommunikálnak a Web Szerverrel, miközben a CGI –k nem igazán. A kérés és válasz objektumok több lehetőséget nyújtanak a Szerverrel való közreműködésre.

▪ Átvihetőség: A Java egy teljesen platform-független nyelv, az összes konténer teljesen kompatibilis egymással, tehát az alkalmazásokat gond nélkül lehet átvinni egyik platformról a másikba.

▪ Olcsó megoldások: A Java, s minden ami hozzá tartozik ingyenes. Az Apache Web szerver is ingyenes.