Fejlett Webes Technológiák II. Bilicki Vilmos

A mai előadás tartalma: CLDC Célok, Követelmények Architektúra, biztonság Eltérés a J2SE-től Eltérés a JVM-től CLDC könyvtárak

Célok, Követelmények, Hatókör Cél: Szabványos, minimális erőforrás igényű Java környezet Horizontális specifikáció Olyan alap létrehozása melyre vertikális specifikációk (profilok) épülhetnek Az alkalmazások biztonságos, dinamikus telepítése

Célok, Követelmények, Hatókör Követelmények: Hardver: 128 kB nem illékony memória 32 kB illékony memória (Java környezet, objektumemória) 16 vagy 32 bites processzor Szoftver: Minimális operációs rendszer vagy kernel Legalább egy időszelet a KVM számára (nincs megkötés a többszálúságra, …)

Célok, Követelmények, Hatókör Hatókör: Java nyelv és a VM lehetőségei Alap Java osztályok (java.lang.*,java.util.*) Input/Output Hálózatkezelés Biztonság Nemzetközi alkalmazhatóság

Architektúra és Biztonság KVM CLDC API Profilok, saját API-k

Architektúra és Biztonság KVM (Kilo Virtual Machine) A lehető legkisebb még ”teljes” Java virtuális gép 40 – 80 kB 16 – 32 bites CISC, RISC processzorok (jelenleg több mint 25 környezetben) Alkalmazás menedzsment: Gyakran nincs fájlrendszer (Letöltés, Betöltés) Rendelkezésre áll valamilyen tároló rendszer (általában C nyelven) Alkalmazások listázása Alkalmazás kiválasztása és futtatása Alkalmazások törlése

Architektúra és Biztonság Biztonság Alacsony szintű - virtuális gép biztonság Java osztályfájl ellenőrző (illegális memória terület, Java objektum memórián kívüli írás) Alkalmazás szintű biztonság J2SE A külső eszközök elérése security manager Homokozó modell: Java osztályfájlok ellenőrzése (alacsony szintű) Korlátozott számú Java API Alkalmazások letöltése, menedzselése gépközeli nyelven van megoldva Csak a VM API-k használhatóak (nincs natív kód hívás) Nem írhatóak felül a rendszer osztályok Egyszerre több alkalmazás is futtatható

Osztály fájl ellenőrzés Előellenőrzés (Off-device verification) Szerveren, fejlesztői gépen történik Olyan adatokat fűz hozzá (stack map) a bájtkódhoz melyeket a második lépcső gyorsan, hatékonyan felhasználhat (10%-al nagyobb kód) Futásidejű ellenőrzés (In-device verification) Végignézi az utasításokat a stack map segítségével szigorú típus ellenőrzést végrehajtva

Osztály fájl formátum Java Archive JAR formátum (30-50% tömörítés) Tartalmaznia kell a Stack-Map bejegyzéseket Néhány Java bájtkódot nem tartalmazhat Az osztályfájlokon kívül tartalmazhat erőforrásokat is (png fájlok) (Class.getResourceAsStream(String name)) Minden osztály definíció tartalmazza a saját szimbólumtábláját (metódus, kivételek, …)

Osztályfájl betöltés J2SE Classpath J2ME Implementáció függő Nem írhatóak felül az alaposztályok Az alkalmazás programozó nem szólhat bele a betöltési sorrendbe

Eltérés a Java specifikációtól Nincs lebegőpont támogatás (a készülékek többségében nincs ilyen) Nincs finalize() metódus támogatás (nem írhatunk saját metódusokat melyeket a gc végrehajt mielőtt az objektumot megszüntetné) Nincsenek gyenge referenciák (gyenge referencia - az objektum akkor is törölhető ha nincs van rá hivatkozás) Nincs JNI A felhasználó nem definiálhat saját osztály betöltőket Hibakezelési szűkítések: A készülékek viselkedése hiba esetén sokfajta lehet, ezért a hibaosztályok egy része nincs megvalósítva (Error – nincs visszatérés) Nincs Daemon thread, Thread group

CLDC osztályok Célok: Az alapvető könyvtárak megvalósítása Kapcsolat lehetősége ! Típusok: java.* javax.*

A J2SE-ből származó osztályok Rendszer osztályok (java.lang.*) Adattípus osztályok (java.lang.*) Gyűjtemény osztályok (java.util.*) Input/Output osztályok (java.io.*) Naptár, idő osztályok (java.util.*) Egyéb hasznos osztályok (java.util.*) Hibakezelő osztályok (java.lang.*)

Rendszer osztályok Rendszer osztályok (alapvetőek a java nyelv számára): java.lang.Object java.lang.Class java.lang.Runtime java.lang.System java.lang.Thread java.lang.Runnable (interfész) java.lang.String java.lang.StringBuffer java.lang.Throwable

Rendszer osztályok java.lang.Object ősosztály (ha egy osztálynak nincs őse akkor ez az osztály lesz az) minden osztály a tömböket is ideértve megvalósítják a metódusait fontosabb metódusai: getClass(Object obj) notify() notifyAll() wait(),wait(long timeout),wait(long timeout, int nanos)

Rendszer osztályok java.lang.Thread (Szál) Egyszerű szekvenciális parancssor a programon belül. Könnyűsúlyú folyamat: megosztva használja a kód és az adat szekciót csökken a ”context-switch” végrehajtási idő Segítségével egyszerre több feladatot végezhetünk: képernyő frissítés hálózat kezelés …

Thread osztály a Thread osztály egy általános szálat valósít meg mely nem csinál semmit a run metódus üres a run metódus felülírásával tudunk feladatot specifikálni két módon tudunk szálat megvalósító osztályt definiálni: a Thread osztályból származtatva és felülírva a run metódust megvalósítva a Runnable interfészt

A run metódus felülírása public class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} } System.out.println("DONE! " + getName()); } }

Futtatás public class TwoThreadsDemo { public static void main (String[] args) { new SimpleThread("Jamaica").start(); new SimpleThread("Fiji").start(); } 0 Jamaica 0 Fiji 1 Jamaica 1 Fiji 2 Fiji 2 Jamaica 3 Fiji 3 Jamaica 4 Jamaica 4 Fiji 5 Fiji 6 Fiji 7 Fiji 5 Jamaica 8 Fiji 6 Jamaica 9 Fiji 7 Jamaica DONE! Fiji 8 Jamaica 9 Jamaica DONE! Jamaica

A Runnable interfész megvalósítása public class SimpleThread implements Runnable { Thread SimpleThread; public SimpleThread(String str) { SimpleThread = new Thread(this, str);} public void start() {SimpleThread.start(); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + myThread.getName()); try { myThread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} } System.out.println("DONE! " + myThread.getName()); }}

Mikor melyik módot válasszuk ? Amennyiben osztályunknak származnia kell valahonnan akkor az interfész a megoldás (MIDlet esetén) Egyébként tetszőleges

A szál életciklusa új futtatható blokkolt halott sleep start suspend wait notify resume done sleeping run metódus kilép stop

Állapotok I. új szál amikor a new operátorral létrehozzuk még nem fut ekkor a new állapotban van runnable a megfelelő erőforrások lefoglalását, a szál adminisztrálását, a szál futását a start metódus segítségével tudjuk elindítani a new állapotból. ebben az állapotban a szál nem feltétlenül fog futni. Az operációs rendszer feladata a megfelelő futási idő biztosítása számára. a szálak közötti váltás operációs rendszer függő (pl.: solaris esetén green threads, windows esetén mindegyik szálnak egy időszelet)

blokkolt szálak a következő módokon kerülhetnek ebbe az állapotba: a sleep() metódus eredményeként (ekkor adott ideig lesz itt) egy olyan művelet végrehajtása esetén mely input/output műveletekkel blokkolt és addig nem tér vissza míg ezek be nem fejeződtek a wait() metódus meghívására (másik szálnak meg kell hívnia a notify vagy notifyAll metódust) amikor olyan objektumhoz próbál hozzáférni amely zárolt a suspend() metódus meghívására (ez már elavult) a resmue() metódussal lehet visszahozni. futtatható állapotba csak úgy kerülhetnek vissza ha a blokkolást előidéző eseménynek megfelelő esemény következik be Állapotok II.

Állapotok III. halott szálak a run metódus kilép hirtelen meghal mert egy kezeletlen kivétel miatt megszűnik a run metódus a stop metódus elavult ezért ne használjuk az isAlive metódus segítségével nézhetjük meg, hogy él-e még.

A run metódus kezelése I. a feladat befejezése után kilép: public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) {} } System.out.println("DONE! " + getName()); } }

Figyeli, hogy ki kell-e lépnie: public void run() { Thread myThread = Thread.currentThread(); while (clockThread == myThread) { repaint(); try { Thread.sleep(1000); } catch (InterruptedException e){} } public void stop() { clockThread = null; } A run metódus kezelése II.

Prioritás a szálak versenyeznek a CPU használatáért nagyobb prioritású szálak előnyben vannak a kisebb prioritású szálakkal szemben a kisebb prioritású szálak csak akkor jutnak CPU időhöz, ha a nagyobb prioritású szálak már nem tartanak igényt a CPU-ra az egyenlő prioritású szálak kezelése operációs rendszer függő win9x, WinNT… az egyenlő prioritású szálak felváltva kapnak CPU időt (időosztás) solaris az egyenlő prioritású szálak csak között csak a feladat befejezése után történik váltás (probléma az önző szálak kezelése) a setPriority() metódussal lehet beállítani egy szál prioritását (MAX_PRIOROTY=10, MIN_PRIORITY=1)

Példa: public class SimpleThread implements Runnable { Thread SimpleThread; public SimpleThread(String str) { SimpleThread = new Thread(this, str); } public void start() { SimpleThread.start(); } public void setPriority(int i) { SimpleThread.setPriority(i); } public void run() { Thread myThread = Thread.currentThread(); for (int i = 0; i < 10; i++) { for (int c = 0; c < ; c++); System.out.println(i + " " + SimpleThread.getName()); } System.out.println("DONE! " + SimpleThread.getName()); }

Egyforma prioritás public class ThreeThreadsTest { public static void main (String[] args) { SimpleThread t; SimpleThread t1; t = new SimpleThread("Jamaica"); t.setPriority(1); t1 = new SimpleThread("Kolumbia"); t1.setPriority(1); t1.start(); t.start(); } 0 Kolumbia 1 Kolumbia 2 Kolumbia 0 Jamaica 1 Jamaica 2 Jamaica 3 Jamaica 4 Jamaica 3 Kolumbia 4 Kolumbia 5 Kolumbia 6 Kolumbia 5 Jamaica 6 Jamaica 7 Jamaica 8 Jamaica 9 Jamaica 7 Kolumbia 8 Kolumbia 9 Kolumbia DONE! Kolumbia DONE! Jamaica

Különböző prioritás public class ThreeThreadsTest { public static void main (String[] args) { SimpleThread t; SimpleThread t1; t = new SimpleThread("Jamaica"); t.setPriority(10); t1 = new SimpleThread("Kolumbia"); t1.setPriority(1); t1.start(); t.start(); } 0 Jamaica 1 Jamaica 2 Jamaica 3 Jamaica 4 Jamaica 5 Jamaica 6 Jamaica 7 Jamaica 8 Jamaica 9 Jamaica DONE! Jamaica 0 Kolumbia 1 Kolumbia 2 Kolumbia 3 Kolumbia 4 Kolumbia 5 Kolumbia 6 Kolumbia 7 Kolumbia 8 Kolumbia 9 Kolumbia DONE! Kolumbia

Megjegyzés olyan szálakat kell írnunk melyek nem önzőek az operációs rendszerek különbözőek, ha platform független programot akarunk írni akkor nekünk kell gondoskodnunk a megfelelő időosztásról a yield() metódus segítségével tudjuk egy szál futását felfüggeszteni és a CPU-t átadni egy legalább ilyen prioritású szálnak nem minden operációs rendszer rendelkezik 10 prioritási szinttel (pl winnt 7) a szálak prioritásukat a létrehozó száltól öröklik

Szálak szinkronizálása Egyes feladatokat nem lehet megoldani egymástól független szálakkal (pl.: közös erőforrás használata módosítása) Hibás működéshez vezethet amennyiben nem gondoskodunk zárolásról a közös erőforrás használatakor pl.: két vagy több szál bankbetétek között végez tranzakciókat. A művelet bármikor megszakadhat (windows) és nem konzekvens állapot maradhat, amit egy másik szál felhasználhat. a problémát az adatmódosító metódus megszakíthatósága okozza

Zárolás synchronized a zárolt objektumhoz csak egy szál férhet hozzá ha egy szál használ egy zárolt objektumot és meghív egy másik szálat akkor a másik szál hozzáférhet az objektumhoz minden objektumnak van egy zárolás számlálója egy szál egyszerre több objektumot is zárolhat a szál ütemező periodikusan aktiválja a szálakat, azok melyek egy zárolt objektumra várakoznak a következő soron kívüli futási jogot kapnak.

wait, notify, notifyAll előfordulhat olyan eset amikor egy szál a másik akciójára vár ilyenkor mivel a közös objektumot zárolt függvényeken keresztül lehet elérni ez végtelen ciklushoz vezetne wait – ha egy szál meghívja a wait() metódust akkor az objektum felszabadul és a szál blokkolva lesz amíg az adott objektumnál egy másik szál meg nem a hívja a notify, notifyAll metódust érdemes a notifyAll metódust használni mivel a másik a blokkolt szálak közül csak egyet szabadít fel azt is véltelenszerűen

Példa: Tároló objektum: Tarolo Adat forrás: Producer Adat nyelő: Consumer main: PTest

Tarolo.java public class Tarolo { private int contents; private boolean available = false; public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } System.out.println("Olvasgatok"); available = false; notifyAll(); return contents; } public synchronized void put(int value) { while (available == true) { try { wait(); } catch (InterruptedException e) { } } System.out.println("Irogatok"); contents = value; available = true; notifyAll(); }

public class Producer extends Thread { private Tarolo tarolo; private int number; public Producer(Tarolo c, int number) { tarolo = c; this.number = number; } public void run() { for (int i = 0; i < 10; i++) { tarolo.put(i); System.out.println("Producer #" + this.number + " beirtam: " + i); try { sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { } }

public class Consumer extends Thread { private Tarolo tarolo; private int number; public Consumer(Tarolo c, int number) { tarolo = c; this.number = number; } public void run() { int value = 0; for (int i = 0; i < 10; i++) { value = tarolo.get(); System.out.println("Consumer #" + this.number + " kiolvastam: " + value); }

public class PTest { public static void main(String[] args) { Tarolo c = new Tarolo(); Producer p1 = new Producer(c, 1); Consumer c1 = new Consumer(c, 1); c1.start(); p1.start(); } Main

Eredmény H:\>java PTest Irogatok Olvasgatok Consumer #1 kiolvastam: 0 Producer #1 beirtam: 0 …. Irogatok Olvasgatok Producer #1 beirtam: 8 Consumer #1 kiolvastam: 8 Irogatok Producer #1 beirtam: 9 Olvasgatok Consumer #1 kiolvastam: 9

Újrafoglalás public class Reentrant { public synchronized void a() { b(); System.out.println("here I am, in a()"); } public synchronized void b() { System.out.println("here I am, in b()"); }

StringBuffer Segítségével karakterlácokat tudunk manipulálni Használata: String x = new StringBuffer().append("a").append(4).append("c").toString()

Throwable Minden hiba osztály őse Használata: try { int a[] = new int[2]; a[4]; } catch (ArrayIndexOutOfBoundsException e) { System.out.println("exception: " + e.getMessage()); e.printStackTrace(); }

Adat típus osztályok Adat típus osztályok: java.lang.Boolean java.lang.Byte java.lang.Short java.lang.Integer java.lang.Short java.lang.Character

Gyűjtemény osztályok java.util.Vector java.util.Stack java.util.Hashtable java.util.Enumeration

Vector Olyan tömböt valósít meg amely objektumokat tartalmazhat és növelhető a kapacitása Használata: Vector vectorName = new Vector(); Vector vectorName = new Vector(5); int vectorSize = vectorName.size(); int objectFirstFoundAt = vectorName.indexOf(objectToSearchFor); Object objectName = vectorName.elementAt(intToGetElementAt); vectorName.add(objectToAdd); vectorName.remove(intOffsetToRemoveElement);

Stack A Vector osztályból származik Last in First Out (LIFO) Hasznos metódusai: Object pop() Object push(Object item) Object peek()

Hashtable Egy olyan táblát definiál melyben kulcsok alapján kereshetünk Olyan objektumokat tárolhatunk melyek megvalósítják a hashCode metódust Használata: Hashtable numbers = new Hashtable(); numbers.put("one", new Integer(1)); numbers.put("two", new Integer(2)); numbers.put("three", new Integer(3)); Integer n = (Integer)numbers.get("two"); if (n != null) { System.out.println("two = " + n); }

Enumeration (interfész) Egy interfészt specifikál Segítségével elemek listáján mehetünk végig Metódusai: boolean hasMoreElements() Object nextElement() Használata: for (Enumeration e = v.elements() ; e.hasMoreElements() ;) { System.out.println(e.nextElement()); }

Input/Output osztályok Input/Output osztályok: java.io.Reader java.io.Writer java.io.InputStream java.io.OutputStream java.io.ByteArrayInputStream java.io.ByteArrayOutputStream java.io.DataOutputStream java.io.DataInputStream java.io.InputStreamWriter java.io.InputStreamReader java.io.PrintStream

Naptár és idő osztályok Naptár és idő osztályok: java.util.Calendar java.util.Date java.util.Timezone

Egyéb hasznos osztályok Egyéb hasznos osztályok: java.util.Random java.util.Math

Kivételkezelő osztályok I. Kivételkezelő osztályok: java.lang.Exception java.lang.ClassNotFoundException java.lang.IllegalAccessException java.lang.InstantiationException java.lang.InterruptedException java.lang.RuntimeException java.lang.ArithmeticException java.lang.ArrayStoreException java.lang.ClassCastException java.lang.IllegalArgumentException java.lang.IllegalThreadStateException java.lang.NumberFormatException java.lang.IllegalMonitorStateException

Kivételkezelő osztályok II. Kivételkezelő osztályok: java.lang.IndexOutOfBoundsException java.lang.ArrayIndexOutOfBoundsException java.lang.StringIndexOutOfBoundsException java.lang.NegativeArraySizeException java.lang.NullPointerException java.lang.SecurityException java.util.EmptyStackException java.util.NoSuchElementException java.io.EOFException java.io.IOException java.io.InterruptedIOException java.io.UnsupportedEncodingException java.io.UTFDataFormatException

CLDC specifikus osztályok javax.microedition.io.* Generic Connection framework Egységes módszer i/o Hálózat támogatás Java.net.* (20 osztály) nem használható BlueTooth, infravörös, … Általános forma: Connector.open( )

Definiált interfészek

Interfészek Connection (csak kinyitni és becsukni lehet, az open() statikus) Public void close() InputConnection – adat olvasható ki public InputStream openInputStream() public DataInputStream openDataInputStream() OutputConnection – adat írható public OutputStream openOutputStream() public DataOutputStream openDataOutputStream() StreamConnection – az előző két interfész kombinációja ContentConnection – a HTTP kapcsolat néhány alapvető paraméteréhez ad hozzáférést public String getType(); public String getEncoding(); public long getLength(); StreamConnectionNotifier DatagramConnection

Példa try { conn = openConnection(); updateProgress(); out = openDataOutputStream(conn); out.writeInt(MessageConstants.LOGIN_USER); out.writeUTF(c.getUsername()); out.writeUTF(c.getPassword()); out.close(); updateProgress(); in = openDataInputStream(conn); updateProgress(); } catch (IOException ioe) { throw new ApplicationException(ErrorConstants.CANNOT_CONNECT); } finally { closeAll(conn, out, in); }

Connector, HttpConnection HttpConnection openConnection() throws IOException { HttpConnection result; result = (HttpConnection) Connector.open(servletUrl); result.setRequestProperty("User-Agent", System.getProperty("microedition.profiles")); result.setRequestProperty("Content-Type", "application/binary"); result.setRequestMethod(HttpConnection.POST); return result; }

DataOutputStream DataOutputStream openDataOutputStream(HttpConnection conn) throws ApplicationException { try { return conn.openDataOutputStream(); } catch (IOException ioe) { throw new ApplicationException(ErrorConstants.CANNOT_CONNE CT); }

Forrás SUN: Connected, Limited Device Configuration (