APNVZ_4 Adaptivní návrhové vzory. Microkernel Reflexe (reflection)

Transkript

1 APNVZ_4 Adaptivní návrhové vzory Microkernel Reflexe (reflection) 1

2 Microkernel - úvod Microkernel se používá pro programové systémy, které musí být schopné se adaptovat na měnící se požadavky systému. Odděluje jádro minimálních funkcí od rozšířené funkcionality a uživatelsky specifických částí. Komponenta microkernel také slouží jako socket (zásuvka) pro vložení těchto rozšíření a koordinaci jejich spolupráce. 2

3 Microkernel Kontext Vývoj několika aplikací, které používají podobné programové rozhraní, které je vytvořeno na stejném funkcionálním jádře. Problém V úvahu se musejí vzít následující požadavky: Aplikační platforma se musí vyrovnat s neustálým hardwarovým a softwarovým vývojem. Aplikační platforma by měla být přenositelná, rozšiřitelná a adaptovatelná, aby umožnila snadnou integraci nových technologií. 3

4 Microkernel Úspěch takovýchto aplikačních platforem dále závisí na jejich schopnosti provozovat aplikace psané pro existující standardy. K podpoře širokého spektra aplikací je třeba více než jeden pohled na funkcionality základní aplikační platformy. Aplikační platforma jako operační systém, nebo databáze, by měla být také schopná emulovat jiné aplikační platformy, které patří ke stejné aplikační doméně. 4

5 Microkernel Jedná se o následující požadavky: Aplikace ve vaší aplikační doméně potřebují podporovat různé, ale podobné aplikační platformy. Aplikace musí být kategorizovány do takových skupin, které používají stejné funkcionální jádro různým způsobem, tím že požadují základní aplikační platformu (microkernel), aby emulovala existující standardy. 5

6 Microkernel Abychom se vyhnuli problémům spojeným s provozem a garantováním škálovatelnosti, naše řešení musí vzít v úvahu ještě další požadavek: Funkcionální jádro aplikační platformy by mělo být rozdělené do komponent s minimální velikostí paměti a služeb, které spotřebují minimální kapacitu procesoru. 6

7 Microkernel Řešení Základní služby aplikační platformy zapouzdřete do komponenty microkernel. Tato komponenta zahrnuje funkcionalitu, která umožňuje jiným komponentám běžet v oddělených procesech a komunikovat spolu. Komponenta microkernel je také odpovědna za údržbu (podporu) systémových zdrojů jako jsou soubory a procesy. Navíc poskytuje rozhraní, které umožňuje jiným komponentám přístup k funkcím komponenty microkernel. 7

8 Microkernel Jádro funkcionality, které nemůže být implementováno uvnitř komponenty microkernel, protože by rozšířilo rozsah a složitost komponenty microkernel, by mělo být vyděleno do interních serverů. Externí servery implementují jejich vlastní pohled základní komponenty microkernel. Každý externí server je samostatný proces, který sám reprezentuje aplikační platformu. Ke konstrukci tohoto pohledu využívají mechanismus dostupný prostřednictvím rozhraní komponenty microkernel. 8

9 Microkernel External Server -calls Microkernel -activates InternalServer +receiverequest() +dispatchrequest() +executeservice() +executemechanism() +initcommunication() +findreceiver() +createhandler() +sendmessage() +callinternalserver() +executeservice() +receiverequest() -initialcommunication servicecall Client +dotask() Klienti komunikují s komponentami externích serverů tím, že používají prostředky poskytované komponentou microkernel. 9

10 Microkernel Struktura Vzor microkernel definuje pět druhů spolupracujících komponent: microkernel interní servery (internal servers) externí servery (external servers) adaptery (emulátory) klienty 10

11 Microkernel Komponenta microkernel implementuje základní služby: jako jsou komunikační prostředky, nebo obsluha zdrojů. Jiné komponenty staví na všech, nebo některých z těchto základních služeb. Dělají to nepřímo prostřednictvím jednoho, nebo více rozhraní, které nabízí komponenta microkernel. 11

12 Microkernel Komponenta microkernel zapouzdřuje mnoho systémově (hardwarově) specifických závislostí. Klienti komponenty microkernel pouze vidí konkrétní pohledy, základní aplikační domény a specifika platformy. Ve stručnosti, komponenta microkernel implementuje atomické (dílčí) služby, které nazýváme mechanismy. 12

13 Microkernel Tyto mechanismy slouží jako základní báze, na které jsou konstruovány složitější funkce nazývané politiky (policies). 13

14 Microkernel - struktura External Server -calls Microkernel -activates InternalServer +receiverequest() +dispatchrequest() +executeservice() +executemechanism() +initcommunication() +findreceiver() +createhandler() +sendmessage() +callinternalserver() +executeservice() +receiverequest() -initialcommunication -sendrequest Adapter -calls service Client +callservice() +createrequest() +dotask() 14

15 Microkernel interní server Komponenta interní server rozšiřuje funkcionalitu komponenty microkernel (dodatečná funkcionalita). Microkernel vyvolává funkcionalitu interních severů přes požadavek služeb. Interní servery mohou takto zapouzdřit některé závislosti základního hardware, nebo software systému, např. ovladače různých grafických karet. 15

16 Microkernel externí server Externí server je komponenta, která používá microkernel pro implementaci vlastního pohledu základní aplikační domény. Externí servery nabízejí svoji funkcionalitu exportováním rozhraní stejným způsobem, jak to dělá samotná komponenta microkernel. Každý z těchto externích serverů běží v samostatném procesu. 16

17 Microkernel - externí server Externí server získá požadavky služeb z klientských aplikací použitím komunikačních prostředků poskytovaných komponentou microkernel. Interpretuje tyto požadavky, vykonává požadované služby a vrací výsledky klientům. 17

18 Klient Klient je aplikace, která je asociovaná přesně s jedním externím serverem. Klient pouze zpřístupňuje programové rozhraní poskytované externím serverem. Problém vzniká, když klient potřebuje přístup k rozhraní svého externího serveru přímo. Každá komunikace s externím serverem musí být neměně zakódovaná do kódu klienta. 18

19 Klient Takové úzké propojení mezi klienty a servery způsobuje mnoho nevýhod: takový systém nepodporuje dobře zaměnitelnost; pokud externí servery emulují existující aplikační platformy, klienti aplikací vytvořené pro tyto platformy nebudou moci pracovat s modifikacemi. 19

20 Microkernel - adapter Proto se mezi klienty a externími servery zavádí rozhraní, které chrání klienty od přímých závislostí tzv. adapter. Adaptery, někdy nazývané jako emulátory, reprezentují toto rozhraní. Dovolují přístup klientům ke službám externích serverů a zachovávají portabilitu. Jsou částí klientského adresového prostoru. Pokud externí server implementuje existující aplikační platformu, odpovídající adapter napodobuje programové rozhraní platformy. Klienti napsáni pro emulovanou platformu mohou být proto kompilováni a spouštěni bez modifikací. 20

21 Microkernel - struktura External Server -calls Microkernel -activates InternalServer +receiverequest() +dispatchrequest() +executeservice() +executemechanism() +initcommunication() +findreceiver() +createhandler() +sendmessage() +callinternalserver() +executeservice() +receiverequest() -initialcommunication -sendrequest Adapter -calls service Client +callservice() +createrequest() +dotask() 21

22 Výhody / nevýhody Výhody Portabilita. Flexibilita a rozšiřitelnost. Škálovatelnost. Spolehlivost. Transparentnost. Úzká místa Výkonnost. Monolitický programový systém bude mít vždy větší výkonnost. Složitost návrhu a implementace. 22

23 Dynamický pohled Client Adapter Microkernel External Server callservice createrequest initcommunication findreceiver receiverequest dispatchrequest executeservice 23

24 Použití interního serveru External Server Microkernel Internal Server executemechanism callinternalserver receiverequest executeservice 24

25 Implementace 1. Analyzovat aplikační doménu. 2. Analyzovat externí servery. 3. Kategorizovat služby. 4. Rozdělit kategorie na služby, které by měly být částí komponenty microkernel a ty které budou dostupné prostřednictvím interních serverů. 5. Určit strategie pro přenos a zpětné získání výsledků. 6. Strukturovat komponentu microkernel. 7. Navrhnout a implementovat interní servery. 8. Navrhnout a implementovat externí servery. 9. Implementovat adaptery. 25

26 Varianty Systém microkernel s nepřímým spojením Klientserver. Klient, který chce poslat požadavek, nebo zprávu externímu serveru požádá komponentu microkernel o komunikační kanál. Poté co je tento kanál vytvořen, komunikace klientserver probíhá nepřímo prostřednictvím microkernelu. 26

27 Varianty Distribuovaný microkernel systém. V této variantě může komponenta microkernel působit jako základní (páteřní) část, zodpovědná za posílání zpráv vzdáleným počítačům, nebo obdržení zpráv od nich. Každý počítač v distribuovaném systému používá svou vlastní implementaci komponenty microkernel. Využití server JBoss 27

28 Server JBoss JBoss využívá microkernelový návrh, kdy každá komponenta může být zasunuta (plugged) v době běhu a rozšiřuje tak chování serveru. U JBosse je každá služba jako (perzistence, transakce, bezpečnost, služba jmen, posílání zpráv, logování ) hot-deployed jako komponenta, běžící na vrcholu velmi kompaktního jádra nazvaného JBoss Server Spine. I uživatelé, mohou implementovat svoje vlastní služby. 28

29 Struktura JBoss JMS (JBOssMQ) User service A EJB container JBoss server spine JNDI (JBossNS) JNDI (JBossNS) Servlet/JSP 29

30 Výhody Přenositelnost (portability) migrace microkernelu do nového HW prostředí pouze vyžaduje modifikace HW závislých částí. Flexibilita a rozšiřitelnost je-li třeba implementovat dodatečný pohled je třeba přidat pouze jeden externí server. Oddělení politik a mechanismů vzor poskytuje mechanismy pro implementaci politik. 30

31 Výhody Transparentnost architektura microkernelu dovoluje přístup j jiným komponentám bez znalosti jejich umístění. 31

32 Slabá místa Nižší výkonnost Složitost návrhu a implementace. 32

33 Souvislost s ostatními vzory Reflexe: poskytuje dvou úrovňovou architekturu. základní úroveň (base level) koresponduje s kombinací microkernelu a interních serverů meta úroveň koresponduje s činností externích serverů, protože ty umožňují dynamicky měnit funkcionalitu, podobně jako metaúroveň vzoru ferlexe. 33

34 Reflection úvod Reflexe (reflection) je schopnost pracovat se třídami (typy) a datovými atributy tříd jako s objekty. Reflection patří mezi adaptivní návrhové vzory. Poskytuje mechanismus pro změnu struktury chování softwarových systémů dynamicky. Podporuje modifikaci základních aspektů jako je typ struktury a mechanismus volání funkcí. 34

35 Reflection - úvod Tento vzor dělí aplikaci na dvě části: meta úroveň poskytuje informace o vybraných vlastnostech systému a umožňuje tak, aby si SW uvědomoval sám sebe. základní úroveň obsahující aplikační logiku. Aplikace je vytvořena na meta úrovni (nad meta úrovní). Změny informací v meta úrovni ovlivňují následně chování základní úrovně. 35

36 Úroveň metamodelu, modelu, dat a procesů Type Meta Model Level Attribute Association Operation Type... Model Level Order Product Type... Employee Data & Process Level Bob Betty Victor 36

37 Vztahy mezi modely a metamodely M3 Metametamodel MOF instance of instance of M2 Metamodel M1 Model Čtyřvrstvá hierarchie OMG ObjectManagement Group Vztahy vrstev vyjádřeny pomocí relace instance_of instance of M0 Data 37

38 Vztahy mezi modely a metamodely 38

39 Kontext, problém Kontext: Budování programových systémů, které apriori podporují svoji vlastní modifikaci. Problém: Programové systémy se vyvíjejí v čase, by měly být otevřené modifikacím na základě změny technologií a požadavků. Pro programové systémy je lepší specifikovat jejich architekturu otevřenou k modifikacím a rozšíření. 39

40 Problém Při řešení problému působí následující síly : Změna software je namáhavá (úmorná), náchylná k chybám a drahá. Softwarové systémy schopné adaptace mají obyčejně složitou vnitřní strukturu. Implementace služeb aplikace je rozšířena na mnoho malých komponent s odlišným vzájemným vztahem. Nevhodné techniky pro akceptování změn systému např. parametrizace, subclassing, copy paste. 40

41 Problém Změny SW mohou mít libovolný rozsah. Mohou být měněny i základní aspekty celého systému. 41

42 Řešení Vytvořit samouvědomující SW (self aware) a učinit některé aspekty této struktury a chování dosažitelnými pro adaptaci a změny. Vede to ke struktuře: meta úroveň a základní úroveň. 42

43 Meta úroveň Meta úroveň poskytuje self-representation programové aplikace a tím poskytuje vědomosti o její vlastní struktuře a chování. Meta objekty zapouzdřují a prezentují informace o programové aplikaci. instanceof «metaclass» java.lang.class instanceof meta level Pes class objects base level instanceof fido 43

44 Základní úroveň Základní úroveň definuje aplikační logiku. Implementace používá metaobjekty, aby udržela nezávislé ty aspekty, u kterých je pravděpodobnost změn. Např. komponenty základní úrovně mohou spolu vzájemně komunikovat prostřednictvím metaobjektu, které implementuje konkrétní uživatelsky definovaný mechanismu volání funkcí. Existuje specifikované rozhraní pro manipulaci s metaobjekty. 44

45 Struktura Meta úroveň je složena s množiny metaobjektů. Každý metaobjekt zapouzdřuje vybrané informace o jednotlivých aspektech struktury, chování, nebo stavu základní úrovně. Jsou tři zdroje těchto informací: 1. Informace jsou poskytovány za běhu prostředím systému. 2. Informace mohou být definovány uživatelem anotace. 3. Informace mohou být zjištěny ze základní úrovně za běhu programu aktuální stav výpočtu. 45

46 Struktura Všechny metaobjekty spolu poskytují vlastní reprezentaci (self-representation) aplikace. Meta objekty vytvářejí informace, které jsou jinak dostupné pouze implicitně. Takto jsou explicitně přístupné a modifikovatelné. Např. v distribuovaných systémech mohou existovat metaobjekty, které poskytují informace o fyzickém rozmístění komponent základní úrovně. Poskytují zjištění, zda komunikující partner je lokální nebo globální. 46

47 Reflekce v Javě balíček java.lang.reflect 47

48 import java.lang.reflect.*; public class DumpMethods { public static void main(string args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getdeclaredmethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); catch (Throwable e) { System.err.println(e); Poznámky Výpis metod třídy java.util.stack Spuštění s jedním argumentem: java DumpMethods java.util.stack c je classobject (objekt třídy) Spouštění: java DumpMethods java.util.stack public synchronized java.lang.object java.util.stack.pop() public java.lang.object java.util.stack.push(java.lang.object) public boolean java.util.stack.empty() public synchronized java.lang.object java.util.stack.peek() public synchronized int java.util.stack.search(java.lang.object) 48

49 Využití reflexe v Javě Nastavení používání reflexe Tři kroku vedoucí k využití balíčku java.lang.reflect. 1. Získat class objekt java.lang.class, se kterým se bude manipulovat. java.lang.class se používá k reprezentaci tříd a rozhraní v běžícím javovském programu. Jednou z možností získání objektu třídy je: Class c = Class.forName("java.lang.String"); získá se Class object pro řetězce Jiný způsob: Class c = int.class; // or Class c = Integer.TYPE; 49

50 Využití reflexe v Javě to vede k získání informací o základních typech. 2. Druhým krokem je zavolat metodu např. getdeclaredmethods(), k získání seznamu všech metod deklarovaných ve třídě. 50

51 Využití reflexe v Javě 3. Po té co jsou informace k dispozici, je třetím krokem využití API reflexe k manipulaci s informacemi. Např. sekvence příkazů: Class c = Class.forName("java.lang.String"); Method m[] = c.getdeclaredmethods(); System.out.println(m[0].toString()); Zobrazí textově první informaci uvedenou v řetězci. 51

52 Reflexe v hierarchii tříd Javy instanceof «metaclass» java.lang.class instanceof meta level Pes class objects base level instanceof fido Objekt fido je instance od třídy Pes. Třída Pes je instance od třídy Class. Třída Class je instancí třídy Class. Třída Class je metatřída, protože její instance jsou třídy. 52

53 Reflexe v hierarchii tříd Javy instanceof java.lang.object instanceof «metaclass» java.lang.class instanceof meta level Pes class objects base level instanceof fido Třída Object nejvyšší třída v hierarchii, metaclasses jsou podtřídami třídy Object. 1. To znamená, že metody třídy Object jsou součástí API reflexe. 53

54 Reflexe v hierarchii tříd Javy instanceof java.lang.object instanceof «metaclass» java.lang.class instanceof meta level Pes class objects base level instanceof fido 2. Všechny javovské třídy jsou instancemi od jedné metatřídy Class. Tyto dvě podmínky vytvářejí cyklus v diagramu. Class.class.isInstance(Object.class); Object.class.isAssignableFrom(Class.class); 54

55 Reflexe v hierarchii tříd Javy instanceof java.lang.object instanceof «metaclass» java.lang.class instanceof meta level Pes class objects base level instanceof fido V Javě má každý objekt jednu třídu, která vytváří instance a všechny třídy jsou podtřídami třídy Object. Třída Object je částí API reflexe. Všechny metatřídy jsou podtřídami třídy Object. Každá z metod reflexe může být používaná v reflektivním programování. 55

56 package prvni; class A { public class Instance1 { public static void main(string args[]) { try { Class cls = Class.forName( prvni.a"); // prvni.a insta = new prvni.a(); //vytvoreni instance // Class cls = insta.getclass(); //vytvoreni class objektu boolean b1 = cls.isinstance(new Integer(37)); System.out.println(b1); boolean b2 = cls.isinstance(new prvni.a()); System.out.println(b2); catch (Throwable e) { System.err.println(e); Poznámky Simulace operátoru instanceof() názvy balíčků se musí také uvádět Výpis: false true 56

57 import java.lang.reflect.*; public class Method1 { private int f1( Object p, int x) throws NullPointerException { if (p == null) throw new NullPointerException(); return x; Poznámky Vyhledání metod dané třídy 1/2 public static void main(string args[]) { try { // Class cls = Class.forName( Method1"); Method1 method1 = new Method1(); Class cls = method1.getclass(); Method methlist[] = cls.getdeclaredmethods(); for (int i = 0; i < methlist.length; i++) { Method m = methlist[i]; System.out.println("name = " + m.getname()); System.out.println("decl class = " + m.getdeclaringclass()); Class pvec[] = m.getparametertypes(); for (int j = 0; j < pvec.length; j++) System.out.println(" param #" + j + " " + pvec[j]); 57

58 Class evec[] = m.getexceptiontypes(); for (int j = 0; j < evec.length; j++) System.out.println("exc #" + j + " " + evec[j]); System.out.println("return type = " + m.getreturntype()); System.out.println("-----"); catch (Throwable e) { System.err.println(e); Poznámky Vyhledání metod dané třídy 2/2 name = f1 decl class = class Method1 param #0 class java.lang.object param #1 int exc #0 class java.lang.nullpointerexception return type = int name = main decl class = class Method1 param #0 class [Ljava.lang.String; return type = void

59 import java.lang.reflect.*; public class Field1 { private double d; public static final int i = 37; String s = "testing"; Poznámky Informace o datových atributech public static void main(string args[]) { try { // Class cls = Class.forName( Field1"); Field1 field1 = new Field1(); Class cls = field1.getclass(); Field fieldlist[] = cls.getdeclaredfields(); for (int i= 0; i < fieldlist.length; i++) { Field fld = fieldlist[i]; System.out.println("name = " + fld.getname()); System.out.println("decl class = " + fld.getdeclaringclass()); System.out.println("type = " + fld.gettype()); int mod = fld.getmodifiers(); 59

60 System.out.println("modifiers = " + Modifier.toString(mod)); System.out.println("-----"); catch (Throwable e) { System.err.println(e); Poznámky Informace o datových atributech name = d decl class = class Field1 type = double modifiers = private name = i decl class = class field1 type = int modifiers = public static final name = s decl class = class field1 type = class java.lang.string modifiers =

61 Volání (exekuce) metody podle jména Program chce vyvolat metodu add(), ale neví to, až do doby běhu programu. To znamená, že jméno metody je určeno až za běhu programu viz, následující program. metoda getmethod() se používá k nalezení metody ve třídě, která má dva integer parametry a odpovídající jméno. po jejím nalezení je přiřazena do objektu Method k vyvolání metody se musí vytvořit seznam parametrů s odpovídajícími integer hodnotami. 61

62 import java.lang.reflect.*; public class Method2 { public int add(int a, int b) { return a + b; public static void main(string args[]) { try { Method2 method2 = new Method2(); Class cls = method2.getclass(); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; // deklarace partypes[1] = Integer.TYPE; Method meth = cls.getmethod( "add", partypes); // dana metoda s uvedenymi parametry Method2 methobj = new Method2(); Object arglist[] = new Object[2]; // počet argumentů arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = meth.invoke(methobj, arglist); Integer retval = (Integer)retobj; System.out.println(retval.intValue()); catch (Throwable e) { System.err.println(e); Poznámky Vyvolání (exekuce) metody podle jména Výpis vrací součet zadaných parametrů: 84 62

63 import java.lang.reflect.*; public class Method2 { public int add(int a, int b) { return a + b; Poznámky Stejný příklad jen efektivnější zápis public static void main(string args[]) { try { Method2 method2 = new Method2(); // instance tridy Class cls = method2.getclass(); // class object // Class partypes[] = new Class[2]; // partypes[0] = Integer.TYPE; // deklarace // partypes[1] = Integer.TYPE; Method meth = cls.getmethod( "add", new Class[] {Integer.TYPE, Integer.TYPE); Method2 methobj = new Method2(); // Object arglist[] = new Object[2]; // počet argumentů //arglist[0] = new Integer(37); // arglist[1] = new Integer(47); // Object retobj // = meth.invoke(methobj, arglist); // Integer retval = (Integer)retobj; Integer vysledek = (Integer) meth.invoke(methobj, new Object[] {37, 47); System.out.println(vysledek); catch (Throwable e) { System.err.println(e); 63

64 import java.lang.reflect.*; public class Constructor2 { public Constructor2() { Poznámky Vytváření nových objektů 1/2 public Constructor2(int a, int b) { System.out.println( "a = " + a + " b = " + b); public static void main(string args[]) { try { Class cls = Class.forName( Constructor2"); Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE; partypes[1] = Integer.TYPE; Constructor ct = cls.getconstructor(partypes); 64

65 Object arglist[] = new Object[2]; arglist[0] = new Integer(37); arglist[1] = new Integer(47); Object retobj = ct.newinstance(arglist); catch (Throwable e) { System.err.println(e); Poznámky Vytváření nových objektů 2/2 Výpis a = 37 b = 47 65

66 import java.awt.point; import java.lang.reflect.constructor; public class ShowReflection { Poznámky Využití konstruktorů public static void main(string args[]) { Constructor[] cc = Point.class.getConstructors(); Constructor cons = null; for (int i = 0; i < cc.length; i++){ // kontrolní výpis System.out.println(cc[i].toString()); // celkový výpis if (cc[i].getparametertypes().length == 2) cons = cc[i]; vybere konstruktor se dvěma parametry try { Object obj = cons.newinstance( new Object[] { new Integer(3), new Integer(4) ); System.out.println(obj); catch (Exception e) { System.out.println("Exception: " + e.getmessage()); 66

67 Poznámky Výpisy public java.awt.point(java.awt.point) public java.awt.point(int,int) public java.awt.point() java.awt.point[x=3,y=4] Třída Point má tři konstruktory 67

68 import java.lang.reflect.*; public class Field2 { public double d; public static void main(string args[]) { try { Class cls = Class.forName( Field2"); Field fld = cls.getfield("d"); Field2 f2obj = new Field2(); System.out.println("d = " + f2obj.d); fld.setdouble(f2obj, 12.34); System.out.println("d = " + f2obj.d); catch (Throwable e) { System.err.println(e); Poznámky Změna hodnot datových atributů 68

69 Balíčky v Javě java.lang.class a java.lang.reflect poskytují programové konstrukce pro získání běhových (run-time) reflektivních informací o třídách a objektech informace typu: nadtřída a její datové typy rozhraní nadtřídy 69

70 Testování serializovatelnosti Testing for Serializability příklad testuje, zda třída objektu, nebo libovolná nadtřída implementovala rozhraní Serializable pomocná třída má pouze statickou metodu isserializable() SerializableTester.isSerializable( java.util.calendar.getinstance()); SerializableTester.isSerializable( new Object()); 70

71 import java.io.serializable; public class SerializableTester { private static final String serial = "java.io.serializable"; public static boolean isserializable( Object obj ) { if ( obj == null ) return false; Class c = obj.getclass(); do { Class[ ] ifaces = c.getinterfaces(); for ( int i = 0; i < ifaces.length; i++ ) if ( serial.equals( ifaces[ i ].getname() ) ) return true; c = c.getsuperclass(); while ( c!= null ); // cykluj, dokud trida je Object return false; Poznámky Metoda getclass() deklarovaná ve třídě Object metoda getinterface() vrací pole rozhraní metoda getsuperclass() vrací nadtřídu 71

72 public class SerializableTest { public static void main(string[] args) { boolean q = SerializableTester.isSerializable( java.util.calendar.getinstance()); if(q) System.out.println("Calendar je serializovatelny"); else System.out.println("Calendar neni serializovatelny"); Poznámky q = SerializableTester.isSerializable(new Object()); if(q) System.out.println("Object je serializovatelny"); else System.out.println("Object neni serializovatelny"); Výpis Calendar je serializovatelný Object není serializovatelný 72

73 Získání běhových informací (run-time) Předpoklad: aplikace nahraje třídu a potřebuje získat informace o třídě java.lang.reflect obsahuje třídy jako: Constructor, Field, Modifier třída ClassInfo očekává jména tříd jako argumenty příkazů DiningPhilosophers Philosopher Philosopher je další třída 73

74 Získání běhových informací Class c = Class.forName(s); Program určí modifikátory třídy (public ), určí, zda se jedná o třídu nebo rozhraní. Program vyvolá metody getdeclaredconstructors() a getdeclaredmethods() a dostane seznamy konstruktorů a metod deklarovaných ve třídě, spolu s jejich atributy, typy argumentů a výjimkami, které mohou být vyhozeny. Program vypíše seznam atributů dané třídy. 74

75 import java.lang.reflect.*; public class ClassInfo { private static String indent = " "; public static void main( String[ ] args ) throws ClassNotFoundException { if ( args.length < 1 ) return; // exit if no classes given for ( int i = 0; i < args.length; i++ ) { new ClassInfo().printInfo( args[ i ] ); System.out.println(); private void printinfo( String s ) throws ClassNotFoundException { Class c = Class.forName( s ); String modifiers = stringifymodifiers( c.getmodifiers() ); String name = c.getname(); if ( c.isinterface() ) System.out.print( modifiers + name ); else System.out.print( modifiers + " class " + name + " extends " + c.getsuperclass().getname() ); Class[ ] interfaces = c.getinterfaces(); if ( interfaces!= null && interfaces.length > 0 ) { if ( c.isinterface() ) System.out.print( " extends " ); else System.out.print( " implements " ); for ( int i = 0; i < interfaces.length; i++ ) { if ( i > 0 ) System.out.print( ", " ); System.out.print( interfaces[ i ].getname() ); Poznámky Parametr třída DiningPhils 75

76 System.out.println( " {" ); System.out.println( indent + "// Constructors" ); Constructor[ ] constructors = c.getdeclaredconstructors(); for ( int i = 0; i < constructors.length; i++ ) printmethod( constructors[ i ] ); System.out.println( indent + "// Other methods " ); Method[ ] methods = c.getdeclaredmethods(); for ( int i = 0; i < methods.length; i++ ) printmethod( methods[ i ] ); System.out.println( indent + "// Fields " ); Field[ ] fields = c.getdeclaredfields(); if ( fields!= null ) for ( int i = 0; i < fields.length; i++ ) printfield( fields[ i ] ); System.out.println( "" ); //end of printinfo method Poznámky private void printmethod( Member m ) { Class rt = null; Class[ ] params, exceptions; if ( m instanceof Method ) { // nonconstructor method Method method = (Method) m; rt = method.getreturntype(); params = method.getparametertypes(); exceptions = method.getexceptiontypes(); 76

77 else { // a constructor Constructor c = (Constructor) m; params = c.getparametertypes(); exceptions = c.getexceptiontypes(); System.out.print( indent + stringifymodifiers( m.getmodifiers() ) + " " + (( rt!= null )? gettypename( rt ) + " " : "" ) + m.getname() + "( " ); for ( int i = 0; i < params.length; i++ ) { if ( i > 0 ) System.out.print( ", " ); System.out.print( gettypename( params[ i ] ) ); if ( params.length > 0 ) System.out.print( " )" ); // at least 1 param else System.out.print( ")" ); // no params if ( exceptions.length > 0 ) System.out.print( " throws" ); for ( int i = 0; i < exceptions.length; i++ ) { if ( i > 0 ) System.out.print( ", " ); System.out.print( gettypename( exceptions[ i ] ) ); System.out.println( ";" ); Poznámky 77

78 //*** printmethod private void printfield( Field f ) { System.out.println( indent + stringifymodifiers( f.getmodifiers() ) + " " + gettypename( f.gettype() ) + " " + f.getname() + ";" ); Poznámky private String stringifymodifiers( int i ) { return (i == 0)? "" : Modifier.toString( i ); private String gettypename( Class c ) { String b = ""; while( c.isarray() ) { b += "[ ]"; c = c.getcomponenttype(); return c.getname() + b; 78

79 reflection.diningphils public class reflection.diningphils extends java.lang.object { // Constructors public reflection.diningphils( ); // Other methods public static void main( java.lang.string[ ] ); private void init( int ); public int getcount( ); public boolean getchopstick( int ); public void setchopstick( int, boolean ); private void initphils( ); public void dumpstatus( ); public int generatetimeslice( ); private boolean moretostart( ); // Fields private int n; private reflection.philosopher[ ] phils; private boolean[ ] chops; private java.util.random r; private static final int maxphils; private static final int maxeat; private static final int mineat; Výpisy Poznámky 79

80 reflection.philosopher class reflection.philosopher extends java.lang.thread { // Constructors public reflection.philosopher( reflection.diningphils, int ); // Other methods public void run( ); public void settimeslice( int ); public boolean geteat( ); public boolean chopsticksfree( ); public void setleftchopstick( boolean ); public void setrightchopstick( boolean ); private void releasechopsticks( ); private synchronized void grabchopsticks( ); private void eat( ); private void think( ); private void takechopsticks( ); private void seteat( boolean ); private void pause( ); // Fields private reflection.diningphils host; private boolean iseating; private int index; private int ts; Výpisy Poznámky 80

81 package reflection; import java.util.random; public class DiningPhils { private int n; private Philosopher[ ] phils; private boolean[ ] chops; private Random r; private static final int maxphils = 24; private static final int maxeat = 4; // seconds private static final int mineat = 1; // seconds Výpisy Poznámky Třída DiningPhils public int getcount() { return n; public boolean getchopstick( int i ) { return chops[ i ]; public void setchopstick( int i, boolean v ) { chops[ i ] = v; private void init( final int N ) { r = new Random(); n = (N < 0 N > maxphils)? maxphils : N; chops = new boolean[ n ]; phils = new Philosopher[ n ]; initphils(); dumpstatus(); 81

82 //*** Create phil threads and start them in random order. private void initphils() { for ( int i = 0; i < n; i++ ) { phils[ i ] = new Philosopher( this, i ); phils[ i ].settimeslice( generatetimeslice() ); phils[ i ].setpriority( Thread.NORM_PRIORITY - 1 ); while ( moretostart() ) { int i = Math.abs( r.nextint() ) % n; if (!phils[ i ].isalive() ) { System.out.println( "### Philosopher " + String.valueOf( i ) + " started." ); phils[ i ].start(); System.out.println( "\nphilosophers Chopsticks" + "\n(1 = eating 0 = thinking) (1 = taken 0 = free)" ); private boolean moretostart() { for ( int i = 0; i < phils.length; i++ ) if (!phils[ i ].isalive() ) return true; return false; Výpisy Poznámky Třída DiningPhils 82

83 public int generatetimeslice() { int ts = Math.abs( r.nextint() ) % (maxeat + 1); if ( ts == 0 ) ts = mineat; return ts; public void dumpstatus() { for ( int i = 0; i < n; i++ ) System.out.print( (phils[ i ].geteat())? 1 : 0 ); for ( int i = n; i < maxphils + 4; i++ ) System.out.print( " " ); for ( int i = 0; i < n; i++ ) System.out.print( (chops[ i ])? 1 : 0 ); System.out.println(); Výpisy Poznámky Třída DiningPhils public static void main( String[ ] args ) { if ( args.length < 1 ) { System.err.println( "DiningPhils <# of philosophers>" ); System.exit( -1 ); DiningPhils self = new DiningPhils(); self.init( Integer.parseInt( args[ 0 ] ) ); 83

84 class Philosopher extends Thread { private DiningPhils host; private boolean iseating; private int index; private int ts; public Philosopher( DiningPhils HOST, int i ) { host = HOST; index = i; public void settimeslice( int TS ) { ts = TS; public boolean chopsticksfree() { return!host.getchopstick( index ) &&!host.getchopstick( (index + 1) % host.getcount() ); public void setleftchopstick( boolean flag ) { host.setchopstick( index, flag ); public void setrightchopstick( boolean flag ) { host.setchopstick( (index + 1) % host.getcount(), flag ); private void releasechopsticks() { host.setchopstick( index, false ); host.setchopstick( (index + 1) % host.getcount(), false ); Výpisy Poznámky Třída Philosopher 84

85 public void run() { while ( true ) { grabchopsticks(); eat(); think(); private synchronized void grabchopsticks() { while (!chopsticksfree() ) try { wait(); catch( InterruptedException e ) { takechopsticks(); notifyall(); private void takechopsticks() { setleftchopstick( true ); setrightchopstick( true ); seteat( true ); host.dumpstatus(); private void eat() { pause(); seteat( false ); releasechopsticks(); private void think() { pause(); Výpisy Poznámky Třída Philosopher 85

86 private void pause() { settimeslice( host.generatetimeslice() ); try { sleep( ts * 1000 ); catch ( InterruptedException e ) { private void seteat( boolean f ) { iseating = f; public boolean geteat() { return iseating; Výpisy Poznámky Třída Philosopher 86