animáció - címke - Oldal 2 a 4-ből

Naprendszer szimuláció – megvalósítás Java nyelven

2025. június 15.2023. március 10. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez a 3. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció megvalósítása Java nyelven

Fejlesztőeszközként a Java Swinges projekthez a JDK+JRE aktuális verziót támogató NetBeans IDE-t használtuk. Hibakeresés során, a modell adatainak ellenőrzését és a működés helyességének egyszerű tesztelését, debuggolást konzolra történő szöveges kiírással oldottuk meg. A megvalósítás során az előre megtervezett osztálydiagramok alapján készült el Java nyelven a forráskód. Az MVC modell szerint elkülönített programrészek külön csomagokba kerültek, ezzel is kiemelve a funkciók szerinti szétválasztást – eleget téve a terv követelményeinek.

Részlet a Java forráskódból

Megmutatjuk a Java forráskódnak azt a részét, ami megvalósítja az elméleti háttérnél ismertetett transzformációs mátrix alkalmazását X tengely körüli elforgatásra, a nézőponttól való távolság függvényében az égitest látható méretének kiszámítását, valamint a 3D→2D leképezést.

Point3D forog = new Point3D(

b.getPozicio().getX(),

b.getPozicio().getY() * Math.cos(forogZ) +

b.getPozicio().getZ() * Math.sin(forogZ),

-1 * b.getPozicio().getY() * Math.sin(forogZ) +

b.getPozicio().getZ() * Math.cos(forogZ));

int egitestMeret = (int)(

(AdatInterfesz.MELYSEG * b.getSize()) /

(AdatInterfesz.MELYSEG - forog.getZ()));

Point2D kepXY = new Point2D(

(forog.getX() * AdatInterfesz.MELYSEG /

(AdatInterfesz.MELYSEG - forog.getZ()) /

size) + origo.getX() - egitestMeret / 2,

(forog.getY() * AdatInterfesz.MELYSEG /

(AdatInterfesz.MELYSEG - forog.getZ()) /

size) + origo.getY() - egitestMeret / 2);

A teljes és megjegyzésekkel ellátott forráskód ILIAS e-learning tananyagban hozzáférhető, letölthető, tesztelhető tanfolyamaink résztvevői számára.

Az elkészült Java Swinges alkalmazás felhasználói felülete

Tapasztalatok

A Java nyelv erősen típusos, így a kötelező és sok lebegőpontos/egész átalakítás miatt észrevehető, hogy a legkisebb égitest (Hold) kissé ugrál.
Az OO szempontból szép Java megvalósítás könnyen módosítható és bővíthető, a funkciók jól csoportosítottak, a felelősségi kör egyértelműen meghatározott.
A projekt megtervezéséhez és elkészítéséhez magasabb szintű absztrakciós készség szükséges.
A példaprogram alkalmas a különböző szakterületek, témakörök (matematika – lineáris algebra, fizika, számítógépes grafika, virtuális valóság modellezése) közötti kapcsolatok felismertetésére, megerősítésére, a (legalább részben) egymásra épülések felderítésére.
A terv átgondolásával, implementálásával gyors, látványos eredmény érhető el, a sikerélmény hamar jelentkezik.

Továbbfejlesztési lehetőségek

Célszerű ötlet a hardveres gyorsítás és 3D megjelenítés megvalósítása.
Felkínálható lenne a felhasználó számára több paraméter módosítása.
Az égitestek lehetnének textúrázhatók is.
Az égitestek pozíciója kiinduló helyzetben lehetne valós.
A szimuláció szükség esetén lehetne elindítható, leállítható, újraindítható, gyorsítható, lassítható.
A terv könnyen implementálható lehet Java3D technológia alkalmazásával, illetve DirectX és/vagy OpenGL támogatással is.
Az égitestek pozíciója és mozgása demonstrálhatna/modellezhetne nevezetes együttállást is, külön esettanulmányként.
A program paraméterezhető lehetne konfigurációs fájlból (amelynek formátuma tetszőleges: INI, XML).
Fejlettebb matematikai modell is alkalmazható lenne.

Forrás

Friedel, A.; Kaczur, S. (előadó: Friedel, A.): Naprendszer szimuláció a Virtuális valóság modellezése tantárgyban, Informatika Korszerű Technikái Konferencia, Dunaújváros, Dunaújvárosi Főiskola, 2012. november 16-17. (előadás hazai konferencián)
Friedel, A.; Kaczur, S.: Naprendszer szimuláció a Virtuális valóság modellezése tantárgyban, Cserny, L.; Hadaricsné Dudás, N.; Nagy, B. (szerk): Dunakavics Könyvek 2. – Az Informatika Korszerű Technikái, Dunaújvárosi Főiskola, Új Mandátum Könyvkiadó, 2014, ISBN 978 963 287 069 4, ISSN 2064-3837, p. 72-84 (magyar nyelvű szakcikk)

Naprendszer szimuláció – objektumorientált tervezés

2023. december 28.2023. február 7. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez a 2. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció objektumorientált tervezése

A Naprendszer égitestjeinek ábrázolása a valódi világban előforduló méretük és távolságuk szerint történik azért, hogy a szimuláció stabil legyen. A példában a Nap és a három belső bolygó szerepel, valamint a Hold. Utóbbi igazolja, hogy nem csak Nap középpontú égitestekre működőképes a modell. A szimuláció diszkrét lépések véges sorozataként valósul meg, az egyes lépések között az égitestek a virtuális térben egyenes vonalú egyenletes mozgást végeznek. Olyan lépésközt kell választani, amely rövid idő alatt kellően nagy változást képes bemutatni, ilyen például az 1 számítási ciklus / 1 nap érték. 10 képkocka / másodperces megjelenítést feltételezve – melyet egy időzítő biztosít – egy virtuális év kb. 37 másodperc alatt telik el, vagyis a Föld ennyi idő alatt tesz meg egy teljes fordulatot a Nap körül. Az égitestek kezdő pozíciója fiktív, nem függ konkrét dátumtól, együttállástól, méretük a jobb láthatóság érdekében torzított.

A program indításakor a szimuláció automatikusan indul, és nincs lehetőség a leállításra. Az alkalmazás felületének tetején foglalnak helyet a kezelő nyomógombok, a többi részt a megjelenítés/transzformált modelltér tölti ki. Futás közben – egyszerű eseménykezelést megvalósítva – lehet változtatni a méretarányt és a nézőpontot, így az ekliptika síkját felülről és elbillentve is ábrázolhatjuk.

Kivételkezelés nem szükséges a programhoz, mert ez egy önálló demonstrációs eszköz, nem épül rá több elem, nem érhetőek el a szolgáltatásai külső programok számára.

Meghatározott cél és a szempontok: a Java projektben a csomagokat az MVC szerint hozzuk létre, a funkciókat logikusan osszuk szét, csoportosítsuk, tartsuk be az objektumorientált szemléletmód elveit, használjunk interfészt, biztosítsuk az egységbezárást, legyen öröklődés, alkalmazzuk a polimorfizmust, legyen szép és elegáns megoldás, legyen a jelölésrendszer UML osztálydiagram. Mindez grafikus asztali Java alkalmazásként valósuljon meg.

A modell csomag (M – Model)

A modellhez 1 interfész és 5 osztály tartozik:

Az AdatInterfesz tárolja a modell számításhoz és megjelenítéshez tartozó konstansait (ezek a szimuláció paraméterei), és metódusfejet nem tartalmaz. A Pont2D osztály egy kétdimenziós pont sémája, valós x és y koordinátapárral, eltol() és túlterhelt tavolsag() metódusokkal. Ennek leszármazottja a Pont3D osztály, amely mindezt három dimenzióban biztosítja, valamint pozícióként és sebességvektorként is használható. Az Egitest osztályból létrehozott objektumnak van mérete, pozíciója, sebessége, színe és tömege. Az interfészt implementálja az Adattar osztály, amelynek egitestLista nevű generikus listája elérhetővé és egységesen kezelhetővé teszi a tervben felsorolt 5 égitestet. A ZIndex osztályú objektumok az égitestek kirajzolásakor szükséges mélységpufferbeli adatot képesek kezelni.

A nézet csomag (V – View)

A nézet 2 osztályból áll:

Az Ablak osztály egy javax.swing.JFrame leszármazott, az alkalmazás teljes grafikus felületét biztosítja, valamint előkészíti az eseménykezelést. Tartalompanelje négy vezérlő nyomógombot tartalmaz és rajta található a rajzpanel objektum, a vaszon. A RajzPanel osztály egy javax.swing.JPanel leszármazott, amely kapcsolatban áll az adattárral, és kezeli a mélységpuffert. Ez felel a szimulált 3D térben lévő objektumok 2D-beli leképezéséért, figyelembe véve a nézőpont elmozdulását is. A rajzolást a felüldefiniált (öröklődés) paintComponent() metódus végzi el.

Az Ablak osztályú objektum elsődleges szerepet tölt be a megjelenítésben, keretbe foglalva a látható komponenseket, vagyis a kezelő nyomógombokat és a modellteret. Az objektum megvalósít egy ActionListener eseménykezelőt, így a program reagálni tud a felhasználó által kiváltott eseményekre. Az ablakobjektum nagyítás és forgatás üzenetek küldésével saját vásznát – és csak azt – frissíti.

A vezérlő csomag (C – Controller)

A vezérlőt 2 osztály valósítja meg:

A Main osztály összefogja a projektet, ez a végrehajtás belépési pontja. Szükség szerint átadja az MVC szerinti objektumok referenciáit egymásnak, ezzel biztosítva a kommunikációt közöttük, valamint el is indítja a szimulációt. A Logika osztály képes az égitestek gyorsulásának és vonzásának kiszámítására, az égitestek mozgatására, továbbá a megjelenítésért felelős komponenst megfelelő időközönként értesíti a képernyő frissítésének szükségességéről, ami az alapbeállítás szerint 30 frissítés másodpercenként.

Naprendszer szimuláció – elméleti háttér

2023. december 28.2023. január 8. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez az 1. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció elméleti háttere

A Naprendszer szimulációhoz elengedhetetlen, hogy ismerjük a homogén koordinátákat, az elemi műveletek egységes megvalósításához szükséges transzformációs mátrixokat, a tömegvonzás elvét és az implementációhoz szükséges MVC modellt.

Homogén koordináták

Számítógépes algoritmusokkal egyszerű a térbeli transzformáció megvalósítása, ha homogén koordinátákat használunk. Segítségükkel az affin transzformációk egységesen kezelhetők. A cél egy egységes matematikai formalizmus alkalmazása. A pontok az égitestek középpontjait fogják jelölni. Legyen a P pont 3D-beli koordinátái: P=(x, y, z). Szükséges egy konstans érték. Ha w≠0, akkor a P pont koordinátái: P=(w·x, w·y, w·z, w). Ha w=1, akkor a P pont normalizált homogén koordinátái: P=(x, y, z, 1). A pontnégyes kijelölése kölcsönösen egyértelmű.

Transzformációk

Koordináta transzformáció során az ábrázolandó grafikus objektum pontjaihoz (tárgypontokhoz) új koordináta-rendszert rendelünk hozzá. Az objektum nem változik (nem torzul, nem változtatja meg az alakját), csupán a nézőpont változik meg. Például: a koordináta-rendszer eltolása, elforgatása, a koordinátatengelyek felcserélése, tükrözése, és a léptékváltás (nagyítás, kicsinyítés, összenyomás, széthúzás), elforgatjuk az ekliptika síkját a szimulált Naprendszerben.

Pont transzformáció esetén a tárgypontokhoz hozzárendeljük azok egy adott szempont szerinti hasonmását. Például: 3D-s tárgyak leképezése 2D-s képre, objektumok eltolása, forgatása, mozgatása, égitestek mozgatása tömegvonzás alapján. Affin transzformációk (egybevágósági és hasonlósági transzformációk) alkalmazása esetén pont képe pont, szakasz képe szakasz, felület képe felület, valamint metsző térelemek eredeti metszésvonala megegyezik azok leképezett metszésvonalával.

A számítógépes grafika területén az affin transzformációk általános alakja (mátrixosan):

A pont a B=(b_x, b_y, b_z) vektorral eltolható. A pont – a T=(t₁₁, t₁₂, …, t₃₃) mátrixot használva – adott szöggel elforgatható, skálázható, tükrözhető. A számítógépes grafikában ezt a transzformációs mátrixot a homogén koordinátákkal alkalmazva, az összes geometriai transzformáció hatékonyan megvalósítható, visszavezethető mátrixok szorzására. Mindezt saját magunk is implementálhatjuk, de része a DirectX és OpenGL rendering pipeline-jának is.

Más módon is lehetne: egyenes és ehhez tartozó szög párossal is dolgozhatnánk.

A tömegvonzás elve

A tömegvonzás bármely két égitest között meghatározott, függ a gravitációs állandótól és az égitestek tömegétől egyenes arányban, az égitestek (tömeg)középpontjainak távolságától fordított arányban. Ez a Newton szerinti értelmezés, amelynek képlete:

A hatás-ellenhatás törvénye miatt a vonzás – egymás felé való gyorsulás – kölcsönös, a gyorsulás az égitestek tömegével fordítottan arányos, sosem nulla. A Naprendszerben a bolygók a Nap körül keringenek, és a bolygóknak lehetnek holdjaik. Egységesen kezelve: égitestek.

A tömegvonzásnak más elméleti megközelítései is vannak: Einstein gödör-modellje, Kepler törvényei, illetve differenciál-egyenletrendszer, integrálszámítás is használható a közelítő képlet helyett (csak ideális modell esetén pontszerű az égitest és gömbszimmetrikus azok tömegeloszlása), illetve ismeretes többféle értelmezés a rendszer/modell stabilitására: Lagrange pontok, Lyapunov stabilitás.

Az MVC modell

A klasszikus megközelítés szerint a szoftveres alkalmazások három, egymástól jól elkülöníthető szereppel rendelkező egységből állnak: modell (model), nézet (view), vezérlő (controller). A Java nyelv Swing komponensei az MVC architektúra szerint működnek.

A vezérlő reagál az érkező eseményre, hozzáfér a modell adatszerkezeteihez, azaz igénybe veszi a modell szolgáltatásait, valamint frissítheti a nézetet. A nézet a vezérlő frissítési kérésére a közvetlenül megkapott adatok alapján, vagy a modelltől elkért adatok alapján frissíti saját magát. A vezérlő határozza meg az alkalmazás, komponens, program működését. Egy modellt több nézet is használhat. A modell közvetlenül is üzenheti a nézetnek, hogy megváltozott. A nézet adja a látványt, amelyet angolul skin vagy „look and feel”-nek neveznek.

Letöltés szimuláció

2025. június 15.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.

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.

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.

Táblázatos komponens testreszabása

2025. június 15.2021. december 20. Szerző: Kaczur Sándor

A Java programozási nyelv egyik ismert GUI csomagja a swing. Ennek népszerű grafikus komponense az adatok táblázatos megjelenítését biztosító JTable komponens. A táblázatos megjelenítéshez több beállítás is szükséges. A JTable egy MVC komponens, így külön kezelendők a modell, nézet és a vezérlő funkcióihoz kötődő beállítások. A modell tárolja az adatokat például DefaultTableModel típusú objektumban, amiben szétválaszthatók a fejlécben és a többi cellákban található adatok. A nézethez tartozik a betűméret, a cellák színezése, az adatok igazítása, megjelenítése, a gördítősáv. A viselkedést, a felhasználói reakciót a vezérlő határozza meg, például rendezés, görgetés, fókusz, kijelölés, oszlopok sorrendjének cseréje.

Feladat

Készítsünk olyan Java swing-es kliensprogramot, amely tetszőleges adatforrásból (XML vagy JSON a hálózatról, JDBC adatbázis kapcsolatból, ORM leképzésből származó objektumokból) képes az átvett adatok grafikus felületen való táblázatos megjelenítésére JTable komponenssel! Építsünk arra, hogy az adatokon kívül metaadatok is rendelkezésünkre állnak! A megoldás legyen univerzális!

Képernyőképek

Modell

A táblázatos GUI komponenst kezdetben inicializálni kell, illetve a benne tárolt adatok is törölhetők, ha újrahasznosításra kerül a sor:

1 2	JTable tbEredmeny=new JTable(); tbEredmeny.setModel(new DefaultTableModel());

Ki kell nyerni a tároláshoz és a megjelenítéshez kötődő adatokat (1. lépés). A metaadatokból a for() ciklus előállítja az oszlopTomb-öt, és az oszlopTipusTomb-be kerülnek az Oracle adattípusból Java objektumtípusként megfeleltetett adatok. Előbbi a fejléc feliratainak szövegeit tartalmazza, és az utóbbi befolyásolja az egyes cellákban az igazítást, illetve hatással van adott oszlop rendezésére is:

ResultSetMetaData rsmd=rs.getMetaData();

String[] oszlopTomb=new String[rsmd.getColumnCount()];

Class[] oszlopTipusTomb=new Class[oszlopTomb.length];

for(int i=0; i<oszlopTomb.length; i++) {

oszlopTomb[i]=rsmd.getColumnName(i+1);

oszlopTipusTomb[i]=Class.forName(rsmd.getColumnClassName(i+1));

}

Ki kell nyerni a tároláshoz és a megjelenítéshez kötődő adatokat (2. lépés). A while() ciklus végigjárja az eredménytábla sorait és Object típusú tömböt állít elő az összetartozó rekord mezőiből. Ezek először generikus listába kerülnek, majd onnan kétdimenziós Object típusú tömbbe:

ArrayList<Object[]> adatLista=new ArrayList<>();

while(rs.next()) {

Object[] rekord=new Object[oszlopTomb.length];

for(int i=0; i<oszlopTomb.length; i++)

rekord[i]=rs.getObject(i+1);

adatLista.add(rekord);

}

Object[][] adatTomb=new Object[adatLista.size()][oszlopTomb.length];

for(int i=0; i<adatTomb.length; i++)

adatTomb[i]=adatLista.get(i);

Mi indokolja a tömbökből álló generikus lista ( adatLista) alkalmazását?

A while() ciklus végrehajtása előtt nem tudjuk lekérdezni, hogy mennyi rekordot kaptunk vissza, így nem tudjuk rögtön az adatTomb-be tenni az adatokat. A Java nyelvben a tömbök mérete fix, és a deklaráció során meg kell adni. Az eredménytábla metaadatai között megtalálható a mezők száma, ami felhasználható a kétdimenziós tömb oszlopszámaként. A generikus lista dinamikus, annyi elemből fog állni, ahány lépésben végrehajtódik a while() ciklus. Ezután a listától lekérdezhető az elemszáma ( adatLista.size()), és ezzel megvan a kétdimenziós tömb sorainak száma, ami eddig hiányzott. Persze használhatnánk Vector-t is a tömbökből álló generikus lista helyett (mert a DefaultTableModel-nek van olyan túlterhelt konstruktora, ami átvenné paraméterként), de ezt inkább nem tesszük, hiszen a Vector már régóta obsolete kollekció.

Előállítjuk a vizuális komponens mögötti adatmodellt. Öröklődéssel kiegészítjük két hasznos függvénnyel, így cellák rajzolása/renderelése és rendezése megkaphatja a szükséges adattípust ( getColumnClass()), valamint letiltható a cellák szerkeszthetősége ( isCellEditable()). Utóbbiak inkább a vezérléshez kötődnek, de modellen keresztül itt és így kell beállítani:

DefaultTableModel dtm=new DefaultTableModel(adatTomb, oszlopTomb) {

Class[] types=oszlopTipusTomb;

@Override

public Class getColumnClass(int columnIndex) {

return types [columnIndex];

}

@Override

public boolean isCellEditable(int row, int column) {

return false;

}

};

Végül a vizuális komponens mögötti adatmodellt kell átadni:

1	tbEredmeny.setModel(dtm);

Nézet

Adott betűtípus, betűstílus és betűméret használható a táblázat fejlécében, celláiban, illetve a betűmérettől függhet a sorok magassága:

Font betutipus=new Font("Tahoma", Font.PLAIN, 18);

tbEredmeny.getTableHeader().setFont(betutipus);

tbEredmeny.setFont(betutipus);

tbEredmeny.setRowHeight(24);

Hasznos ha JScrollPane típusú gördítősáv tartozik a táblázathoz, így dinamikusan megjeleníthető/elrejthető a függőleges/vízszintes gördítősáv:

1	spGorditosav.setViewportView(tbEredmeny);

Vezérlés

Az adatokhoz valahogyan hozzá kell jutni. Most JDBC kapcsolatot használunk és az Oracle HR sémából kérdezünk le adatokat, de a forráskód-részlet univerzális. A folyamat a következő:

Betöltjük a driver osztályt.
Autentikációval c kapcsolatot nyitunk az adatbázis-szerver felé.
Végrehajtjuk a lekérdező SQL parancsot.
Feldolgozzuk az eredményül kapott ResultSet típusú rs objektumot.
Végül lezárjuk a c hálózati kapcsolatot.

Class.forName(driver);

Connection c=DriverManager.getConnection(url, user, password);

ResultSet rs=c.createStatement().executeQuery(sql);

//...

c.close();

Ha engedélyezzük, akkor a megjelenő táblázat fejlécében az egyes oszlopok felirataira kattintva elérhetjük, hogy az adott oszlop típusának megfelelően növekvő vagy csökkenő sorrendbe átrendeződjenek az adatok:

1	tbEredmeny.setAutoCreateRowSorter(true);

A kivételkezelést nem részleteztük a fenti forráskódoknál, de természetesen kötelezően adott.

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 feladat a Java SE szoftverfejlesztő tanfolyam 45-52. óra: Adatbázis-kezelés JDBC alapon, illetve Java adatbázis-kezelő tanfolyam 9-12. óra: Oracle HR séma elemzése, 33-36. óra: Grafikus kliensalkalmazás fejlesztése JDBC alapon, 2. rész alkalmaihoz kapcsolódik.