szálkezelés - címke - it-tanfolyam.hu

Kockadobás kliens-szerver alkalmazás

2024. július 24.2024. július 21. Szerző: Kaczur Sándor

Fejlesszünk elosztott, hálózatos, datagram alapú üzenetküldéssel megvalósított Java alkalmazást!

A kockadobás kliens egyszerre két szabályos dobókockával dob, amit ezerszer megismétel és a dobott számok összegét datagram típusú üzenetküldéssel folyamatosan elküldi a szervernek. A szerver localhost-on fut és egy megadott porton keresztül várja a klienstől. A szerver és a kliens egyaránt szálkezelést alkalmazó konzolos alkalmazás.

A projektben van egy swing GUI-s alkalmazás, amely JFreeChart oszlopdiagramon – folyamatosan frissítve – megjeleníti az összesített adatokat, mindez a szerver üzenetküldésével irányítva (amint beérkezik egy dobott (2-12-ig) összeg).

A kommunikációnak – a lehetőségekhez képes – biztonságosnak és – a hálózati adatforgalmat tekintve – takarékosnak kell lennie! Ennek részeként szükséges egy azonosító és egy egyszerű szabály (protokoll).

Tekintsük át mondatszerűen a szálkezelést használó kliens és szerver kommunikációhoz kötődő feladatait:

Kliens (háttérszálon):

ciklus 1-től 1000-ig egyesével

DatagramSocket létrehozása

dobás1, dobás2, dobásÖsszeg előállítása

üzenet előállítása //pl.: "12;kocka2#"

DatagramPacket létrehozása

üzenet elküldése a szervernek

visszhang/log kiírása a konzolra

DatagramSocket lezárása

várakoztatás

ciklus vége

Szerver (háttérszálon):

ciklus(végtelen)

DatagramSocket létrehozása

DatagramPacket létrehozása

üzenet fogadása a klienstől

DatagramSocket lezárása

ha(valid az üzenet) akkor

dobásÖsszeg feldolgozása

ablak grafikonjának frissítése (GUI szálon)

elágazás vége

ciklus vége

Ezek működését összefogja egy központi vezérlőosztály és ez a fejlesztőeszköz projektablakában így jelenik meg (egyetlen MVC Java projektként):

A program két felületen kommunikál. A háttérben konzolosan logol a kliens, és a háttérben futó szerver időnként frissítteti a grafikus felhasználói felületen (GUI, ablak) megjelenő grafikont:

Aki kedvet kapott: bátran készítse el a fenti terv/koncepció/specifikáció alapján az MVC Java projektet. Érdemes alaposan tesztelni: külön a szervert, külön a klienst, először indítva az egyiket, majd a másikat, leállítani az egyiket majd fordítva. Átgondoltan indokolni is hasznos, vajon mi, hogyan és miért történik.

A bejegyzéshez tartozó forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A feladat a Java EE szoftverfejlesztő tanfolyam 1-8. óra: Elosztott alkalmazások, webszolgáltatások, szálkezelés, párhuzamosság alkalmához kapcsolódik. Amikor itt járunk a tananyagban, akkor a GUI felület és a grafikon tervezése, megvalósítása már magabiztosan megy, így elegendő a hálózati kommunikációra helyezni a fókuszt.

INFIMUM 2024

2024. június 19.2024. június 14. Szerző: Kaczur Sándor

Az INFIMUM 2024 Konferenciát a Neumann János Egyetem GAMF Műszaki és Informatikai Karán került megrendezésre, Kecskeméten, 2024. június 14-15-én.

A konferencia céljai

A rendezvény elsődleges célja annak elősegítése, hogy a felsőoktatási intézmények oktatói és kutatói az informatika, a fizika, a matematika és a logisztika korszerű és hatékony oktatásáról és tudományos eredményeiről előadások, poszter-bemutatók és személyes találkozás révén tapasztalatot cserélhessenek, valamint kapcsolatot építhessenek.

A konferencia tervezett főbb témakörei

a korszerű matematika-, fizika-, logisztika- és informatikatanítás és tanulás új útjai és távlatai, oktatásfejlesztési tapasztalatai,
a felsőoktatás alapozó tárgyainak oktatás-módszertani problémái,
mesterképzésbe való bekapcsolódás, a duális képzés gondjai és tapasztalatai,
matematika, fizika, informatika, logisztika tudományos eredményei,
új és innovatív kutatási irányok, problémák és gyakorlati alkalmazások bemutatása a fenti tudományterületeken.

A konferencia programja

A letölthető absztraktkötet tartalmazza a szervezőbizottság által összeállított programot. Pénteken került sor a szakmai programra. Szombaton zajlott a Strázsa túra, utána az EB meccset lehetett megnézni a GAMF udvarán, végül borkóstolóval zárul a rendezvény.

A konferenciára 37 résztvevő regisztrált és tartott plenáris vagy szekcióelőadást. A Matematika oktatása szekció 18 előadásból, az Informatika szekció és a Fizika szekció pedig egyaránt 5-5 előadásból állt.

Az absztraktok ISBN 978-615-6435-83-5 számmal rendelkező absztraktkötetben jelentek meg. Lehetőség volt hosszabb, 1-2 oldalas összefoglalók megjelentetésére is. A szakmai cikkek a Gradus lektorált, online folyóiratba egyénileg nyújthatók be magyar vagy angol nyelven, maximum 10 oldal terjedelemben (utólag is). A folyóirat (ISSN 2064-8014) eredeti publikációkat közöl számos témakörben, beleértve a természettudományok minden területét, mindenféle műszaki tudományt, számítástechnikát, kertészetet, környezetmérnökséget, pedagógiát, didaktikát és közgazdaságtant. A számítástechnika és a matematika elméleti és alkalmazott területeit is befogadja. A folyóirat csak kutatási cikkeket közöl, és minden cikk az esettanulmányok, kísérletek, vagy a gyakorlatban már alkalmazott megközelítésekkel való szisztematikus összehasonlítások révén előrehaladó ötletek gyakorlati alkalmazását tárgyalja.

Részt vettem a konferencián

2024-ben egy szakmai előadást tartottam 20 percben Letöltés szimuláció – esettanulmány Java nyelven címmel. Erről a témáról szól korábbi blog bejegyzésem, lásd: Letöltés szimuláció.

Szakmai előadásom összefoglalója

A szerző letöltési folyamatot szimulál. A paraméterek rugalmasan beállíthatóak. Előre beállított mennyiségű adatokat, párhuzamos szálakon/folyamatokon keresztül tölt le, miközben méri az eltelt időt. A folyamatok állapota lehet inaktív, aktív és befejezett. Az aktív folyamatok esetében megjelenő százalék fejezi ki, hogy a folyamat hol tart a rá jutó részfeladat végrehajtásával. Összesített formában követhető a hiányzó és a letöltött adat mennyisége MB-onként és százalékosan is. A folyamat szimulációjához objektumorientált szemléletű, grafikus felhasználói felületű Java kliensprogram készült, egyszerű GUI komponensekkel. Az előadás/cikk bemutatja feladatspecifikációt, a tervezés és megvalósítás lépéseit, ismertet tesztelési és továbbfejlesztési lehetőségeket. A szimuláció megközelítése elvi/általános szintű. Az esettanulmány konkrét adatokkal paraméterezett. Kitér az elosztott alkalmazások különböző felépítési, tervezési, megvalósíthatósági lehetőségeire.

A konferencia a korábbi MAFIOK konferenciasorozat hagyományait követi. Ezen 2023-ban is részt vettünk és beszámoltunk róla az it-tanfolyam.hu szakmai blogban, lásd: MAFIOK 2023. Ott korábbi, MAFIOK-os publikációinkat is felsoroltuk.

A Java SE szoftverfejlesztő tanfolyamunkon, a szakmai modul Objektumorientált programozás témakörét követő 29-36. óra Grafikus felhasználói felület alkalmain már tudunk egyszerűbb szimulációs programot tervezni, kódolni, tesztelni. A Java EE szoftverfejlesztő tanfolyamunkon, a szakmai modul 5-8. óra Szálkezelés, párhuzamosság alkalommal többféle elosztott stratégiát ismertetünk, és a 17-24. óra Socket és RMI alapú kommunikáció alkalommal pedig megvalósíthatjuk többféle protokoll szerint a hálózati kapcsolatot, letöltést/feltöltést.

Letöltés szimuláció

2023. július 26.2022. június 15. Szerző: Kaczur Sándor

Letöltési folyamatot szimulálunk. A paraméterek rugalmasan beállíthatóak. Előre beállított mennyiségű adatot, párhuzamos szálakon/folyamatokon keresztül töltünk le, miközben mérjük az eltelt időt. A folyamatok állapota lehet inaktív, aktív és befejezett. Az aktív folyamatok esetében megjelenő százalék fejezi ki, hogy a folyamat hol tart a rá jutó részfeladat végrehajtásával. Összesített formában követhetjük a hiányzó és a letöltött adat mennyiségét MB-onként és százalékosan is. A folyamat szimulációjához grafikus felületű Java kliensprogram készült, egyszerű GUI komponensekkel (nyomógomb, címke, folyamatindikátor, másképpen JButton, JLabel, JProgressBar swing komponensek).

Az alábbi animáció bemutatja a letöltés szimulációját:

A konkrét paraméterek: 128 MB-nyi adatot töltünk le 256 párhuzamos szálon/folyamaton keresztül, így egy-egy részfeladat 0,5 MB-nyi adat letöltését jelenti. Minden értéket/mérőszámot egész számként ábrázolunk, akár százalékhoz tartozik, akár mértékegységként MB vagy s. A változások – és egyben a frissítés is – 5 ezredmásodpercként történnek a GUI-n.

Elosztott alkalmazások esetén többféleképpen is modellezhető és kialakítható a rendszer architektúrája. Elosztott lehet maga a hálózat, a számítási folyamat, az algoritmus. Elosztott objektumok kommunikálhatnak egyenrangúnak tekinthető P2P szerepkörben vagy szerver/kliens oldalon, és több dolog/elem/hardver/szoftver/komponens együttműködéseként is megvalósulhat elosztott alkalmazás. A hálózati kommunikáció folyamatát valamilyen protokoll határozza meg, amit minden komponens ismer és így meghatározott szabályrendszer szerint működik.

Hardver szinten elosztottak a többprocesszoros rendszerek. Szoftveresen elosztott például egy moduláris vállalatirányítási rendszer, illetve a mobilalkalmazások többsége. Tipikus háromrétegű webalkalmazás esetén külön szerver nyújtja az adatbázishoz kapcsolódó szolgáltatásokat, a felhasználó számítógépén található a böngészőben futó/megjelenő kliensprogram/weboldal és a kettő között a felhő rétegben lehet a funkcionálisan elosztott alkalmazáslogika (például validálás, titkosítás, tömörítés, autentikáció, autorizáció).

A vezérlést megvalósító részlet a Java forráskódból:

private void processControl() {

if(processList.isEmpty()) {

timer.stop();

return;

}

int index=(int)(Math.random()*processList.size());

int oldValue=processList.get(index).getValue();

int increase=(int)(Math.random()*3+1)*10; //5, 10, 15

increase=oldValue+increase<=MAX ? increase : MAX-oldValue;

downloadedSumPercent+=increase;

int newValue=oldValue+increase;

processList.get(index).setValue(newValue);

if(newValue==MAX)

processList.remove(index);

int openProcessCount=0, inactiveProcessCount=0;

for (JProgressBar pb : processList) {

int v=pb.getValue();

if(v==MIN)

inactiveProcessCount++;

if(MIN<v && v<MAX)

openProcessCount++;

}

lbInactiveProcessCount.setText(""+inactiveProcessCount);

lbOpenProcessCount.setText(""+openProcessCount);

lbClosedProcessCount.setText(""+

(PROCESS_COUNT-(openProcessCount+inactiveProcessCount)));

int downloadedData=

(int)((double)downloadedSumPercent/(PROCESS_COUNT*MAX)*DATA);

lbMissingData.setText(""+(DATA-downloadedData));

lbDownloadedData.setText(""+downloadedData);

pbProcess.setValue((int)((double)downloadedData/DATA*100));

elapsedTime+=5;

if(elapsedTime%1000==0)

lbElapsedTime.setText(""+elapsedTime/1000);

}

A szimuláció elvi szinten:

a folyamatok generikus listában vannak,
időzítő által meghatározottan, gyorsan és ismétlődve történnek az időzített lépések,
ha egy folyamat befejeződik, akkor kikerül a generikus listából,
ha a folyamatok generikus listája kiürült, akkor vége a szimulációnak,
ki kell választani véletlenszerűen egy folyamatot, léptetni kell véletlenszerűen, amíg be nem fejeződik,
folyamatosan nyilván kell tartani a szükséges adatokat a háttérben,
folyamatosan frissíteni kell a felhasználói felületet.

Haladóbb megközelítésben másképp is lehetne: a számítási műveletek redukálhatóak lennének, ha lenne egy – minden olyan adat karbantartásáért felelős – modellobjektum, amelynek adatai hozzá lennének rendelve a GUI komponensekhez. Aki már sejti, annak megerősítem, hogy igen, ez observer (megfigyelő) tervezési minta.

A feladat könnyen általánosítható, például:

Egy keresési feladatot oldjunk meg az állományrendszerben! Kereshetünk egy konkrét nevű fájlt, adott kiterjesztésű fájlt, joker karakterekkel paraméterezett nevű fájlt/mappát, adott méretű állományt, adott dátum előtt létrehozott fájlt… Az állományrendszer bejárása rekurzív módon történik. A gyökérben lévő mappánként külön, esetleg második szinten lévő mappánként külön indíthatók szálak, párhuzamos folyamatok. Ha egyetlen találat elegendő, akkor bármelyik szál pozitív visszajelzésére minden szál leállítható. A feladatnál nagy eséllyel nagyon különböző méretű mappákon és eltérő mélységű mappaszerkezeteken kell végighaladni, így erre érdemes lehet optimalizálni, de ez már nagyon más szintje ennek a problémának.
Active Directory szerkezetben keressünk elérhető nyomtatókat a hálózaton!
Elosztott számítási hálózatként működik/működött a SETI@home. Koncepciójának lényege, hogy egy hatalmas feladatot nem nagyon drága szuperszámítógépeken, hanem olcsó gépek ezrein, százezrein, vagy akár millióin végeztetjük el, amelyek jelentős szabad kapacitással (pl. processzoridővel, átmeneti tárhellyel) rendelkeznek és egyébként is csatlakoznak a világhálóra.
Hasonlóan elosztott működésű a torrent protokoll. A kliensek/szálak az állományokat több kisebb darabban/szeletben töltik le, természetesen párhuzamosítva. Minden csomópont megkeresi a hiányzó részhez a lehető leggyorsabb kapcsolatot, miközben saját maga is letöltésre kínálja fel a már letöltött fájldarabokat. A módszer nagyon jól beválik nagyméretű fájloknál, például videók esetében. Minél népszerűbb/keresettebb egy fájl, annál többen vesznek részt az elosztásában, ezáltal a letöltési folyamat gyorsabb, mintha mindenki egy központi szerverről töltené le ugyanazt (hiszen az informatikában minden korlátos, a sávszélesség is).
A képtömörítést végző algoritmusok is lehetnek elosztottak, ezáltal párhuzamosíthatóak. Például ha felosztjuk a képet 16*16-os méretű egymást nem átfedő részekre, akkor ezek egymástól függetlenül tömöríthetők.
A merevlemezek esetén korábban használatos defragmentáló szoftverek felhasználói felülete emlékeztet a mintafeladat ablakára.

Fontos szem előtt tartani, hogy a grafikus megjelenítés csupán a szimulációhoz tartozó – annak megértéséhez szükséges – reprezentáció, így teljesen független lehet a folyamatok valós működésétől.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Egy példányban futó Java program

2023. november 2.2022. január 17. Szerző: Kaczur Sándor

Gyakran észrevesszük, hogy a programok futtatásakor vannak bizonyos korlátok. Például egyszerre általában csak egyetlen telepítőprogram futhat egy operációs rendszeren. Vagy amíg fut egy program korábbi verziójának eltávolítása, addig nem futhat a program új verziójának telepítője. Vagy egy nagyobb erőforrás igényű program (periféria meghajtó program, képernyő videó+hang rögzítő, hardveres gyorsítást használó játékprogram) egyszerre csak egy példányban indítható el. Előfordulhat kategóriánkénti korlát is, például a különböző víruskereső programok általában „nem tűrik meg” egymást, kizárólagosságot „követelnek”.

Lássunk példát arra, hogyan kell készíteni egy példányban futó Java programot!

Néhány dolgot át kell gondolni:

Amikor először indítjuk el a programot, akkor olyan egyedi dolgot kell beállítani, ami mindvégig úgy marad, amíg a program fut. Ezt megtehetjük a memóriában, de megfelelő jogosultsággal futtatva a programot akár beleírhatunk a Windows rendszerleíró adatbázisába (Registry) is. Előbbi módszer platformfüggetlen lenne – ahogyan egy Java programhoz illik –, és az utóbbi megoldás pedig operációs rendszertől függne.
Amikor többedszer (második, harmadik… példányban) indítjuk el a programot, akkor ezt az egyedi dolgot észlelni kell és meg kell akadályozni a program másodszori, harmadszori elindítását. Hasznos, ha ezekben az esetekben kapunk hibaüzenetet, például: „This application is already running”.
Amikor a programot szabályosan állítjuk le, akkor a korábban beállított egyedi dolgot semmissé kell tenni. Ez biztosítja, hogy a program egymás után – egymással nem párhuzamosan, egymástól függetlenül – elindítható lesz.

A megoldás két részből áll. Ez a Java forráskód első része:

private static ServerSocket ss=null;

static {

try {

ss=new ServerSocket(65001, 10, InetAddress.getLocalHost());

}

catch(UnknownHostException e) {

;

}

catch(IOException e) {

JOptionPane.showMessageDialog(null,

"This application is already running.",

PROGRAM_STUDENT_TITLE, JOptionPane.ERROR_MESSAGE);

System.exit(0);

}

A program indulásakor le kell futni a fenti forráskódnak. A static blokk a konstruktor előtt hajtódik végre (például a modell vagy a nézet rétegben). A java.net csomag kötetlen ServerSocket osztályú ss nevű objektumát kell inicializálni helyben ( InetAddress.getLocalHost()) egy nem dedikált porttal ( 65001). Ez elsőre mindig sikerült és az objektum „beül a memóriába” egy nem blokkoló elven működő háttérszálon. Ha (többedszerre) nem sikerül létrehozni az objektumot, akkor – kezelve a kötelezően kezelendő kivételeket – hasznos jelezni ezt logban, konzolon vagy felbukkanó párbeszédablakban és a programból ki kell lépni (másképpen: a duplikált futtatását meg kell akadályozni).

Ez a Java forráskód második része:

try { //a program csak 1 példányban futhat

if(ss!=null && !ss.isClosed())

ss.close();

System.exit(0);

}

catch(IOException e) {

;

}

A programból való szabályos kilépéskor le kell futni a fenti forráskódnak. Ez ellenőrzést követően lezárja az ss objektumot és kilép a programból. Például a main() metódusban, ha elfogynak az utasítások egy konzolos alkalmazásban, vagy GUI-s programban nyomógombra kattintás actionPerformed() esemény, vagy (fő)ablak bezárásának kísérlete WindowClosing() esemény.

A programot érdemes körültekintően tesztelni. Ha elrontjuk a fenti felsorolásban vázolt logikai működés végrehajtásának sorrendjét, akkor fejlesztés vagy tesztelés közben akár a számítógépet is újra kell indítanunk.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

A Java EE szoftverfejlesztő tanfolyamunkon, a szakmai modul 5-8. óra Szálkezelés, párhuzamosság alkalommal megismerjük a megoldás elméleti hátterét és a 17-24. óra Socket és RMI alapú kommunikáció alkalommal többféle megvalósítást is kódolunk, tesztelünk.

Múzeumok Éjszakája 2020 – Java EE online tesztkérdések

2024. június 29.2020. június 27. Szerző: Balogh Péter

2020. június 27-én, szombaton került sor a XVIII. Múzeumok Éjszakája programsorozatra, az ismert körülmények miatt online. A hagyományos múzeumi ünnepen az éjszakába nyúló programok helyett online játékokkal és kvízekkel várták a szervezők az érdeklődő közönséget.

Online játékok és kvízek

A Magyar Nemzeti Múzeum ezt az 5 db online játékot/kvízt készítette az alkalomra:

Seuso lakomáján
Kalandos századok – A Magyar Nemzeti Múzeum története
Ismerd meg 1848-49 nemzeti ereklyéit!
Historizáló magyar falfestészet
A Magyar Nemzeti Múzeum az ostrom idején

Saját programunk

Az it-tanfolyam.hu oktatói csapata az elmúlt években számos tesztet készített. Ezek tanfolyamaink hallgatói számára érhetőek el ILIAS e-learning tananyagként. Tanfolyamaink tematikáihoz illeszkedően, témakörönként, fejezetenként állnak rendelkezésre. Több száz tesztkérdésünk van. Többféleképpen készíthetünk belőlük kérdésbankokat, amelyekből az ILIAS rögzített vagy véletlenszerű módon válogat egyetlen vagy több kérdésbankból is egyszerre. Az online tesztek kétféleképpen férhetők hozzá: gyakorló vagy vizsga módban. Előbbi időben és kitöltésszámban korlátlan lehetőséget biztosít a felkészülés, önálló gyakorlás során. Utóbbi egyszer tölthető ki és időkorlátos.

Ötletet merítve az idei, különleges Online Múzeumok Éjszakájára meghirdetett programokból: összeválogattunk egy speciális, 40 kérdésből álló tesztet, kifejezettem erre az alkalomra. Tanfolyamaink aktív és alumni hallgatóival megosztottuk a tesztet ILIAS-ban. Az alábbi 6 db tesztkérdéssel ízelítőt nyújtunk az it-tanfolyam.hu szakmai blogban ezekből a tesztkérdésekből, amelyek a Java EE szoftverfejlesztő tanfolyamunk tematikájához kötődnek. Az ILIAS-ból letölthető eredményeket megosztottuk a kitöltőkkel. A kitöltés és a megosztás is anonim történt. Így mindez kiváló lehetőség volt arra, hogy mindenki pozicionálja magát a többiekhez képest. Terveink szerint a következő tanfolyami alkalmak során ki is elemezzük a tesztkérdéseket. Íme az ízelítő a speciális tesztből:

1. Mire használható a synchronized kulcsszó?

Használható metódusok deklarációjában, ebben az esetben csak egy végrehajtási szál hívhatja meg a metódust egy időben.
Változók deklarációjában, így az létrehozott változó szálbiztos.
Használható blokk előtt, megadva a referenciát, amin szinkronizálni kell. Ebben az esetben ezt a kódrészletet csak egy végrehajtási szál hívhatja meg egy időben.
Osztályok konstruktorában használható.

2. Melyik annotációk használhatók XML fájlok feldolgozására?

@XmlElement
@Override
@XmlRootElement
@param

3. Elemezze a következő kódrészletet! Jelölje be az egyetlen igaz választ!

while((userInput=stdIn.readLine())!=null){

oos.writeUTF(userInput);

String serverInput=ois.readUTF();

System.out.println(serverInput);

}

Az alkalmazás holtpontba kerülhet, mert nem hívjuk meg az oos objektum flush() metódusát.
Az ObjectInputStream-nek nincs readUTF() függvénye.
A Socket API-ban nem használható objektumfolyam.
Egy elosztott alkalmazás esetében nincs értelme a konzol használatának.

4. Mely állítások igazak JPA entitás osztályok esetében?

A JPA-ban használt entitás osztályokban (melyek adatbázis táblákat reprezentálnak) lehetőség van más entitásokra (táblákra) mutató kapcsolatok kifejezésére.
Az összetett kulcsokat nem tudjuk ábrázolni.
@Id annotációval megjelölt változó elsődleges kulcsot jelent.
Minden entitás osztályban szükséges egy paraméter nélküli üres konstruktor.

5. Jelölje be az összes igaz állítást!

JSP lapon <jsp:useBean/> tag Java Bean objektum deklarálására használható.
JSP lapon csak HTTP POST kérések dolgozhatók fel.
JSP kérés paramétereket a getParameter(String param) függvénnyel kaphatjuk meg.
JSP lapon nem használható webes űrlap.

6. Jelölje be az összes jó választ a JMS specifikáció esetében!

A JMS üzenetek a Java e-mail szolgáltatását valósítják meg.
Az egyik EJB fajta a Message-driven Bean, amely JMS üzenetek feldolgozására való.
A JMS szolgáltatás két lehetősége a Queue és a Topic.
JMS üzeneteket feldolgozhatunk egy Servletben is.