Metaprogrammierung. Metaprogrammierung. 1 von 38

Transkript

1 1 von 38

2 Überblick 2 von 38

3 , was ist das? Allgemein Es wird eine übergeordnete Ebene (Meta-) oberhalb der "normalen" Programmierung (mit Typen, Kontrollstrukturen, Objekten, Methoden, etc.) realisiert. Definition ist die Disziplin, Programme zu schreiben, die andere Programme oder sich selbst repräsentieren oder manipulieren. weitere Merkmale Vielfach Erzeugung oder Ergänzung der Zielprogramme durch Metaprogramme (Begriff: generative Programmierung). Dabei oft Schablonen als Vorlage für die Generierung. Teils eigene Sprache (Metasprache) für Metaprogramme. Spezialfall Reflection: Metaprogramme in derselben Sprache wie die Zielprogramme. Die Abstraktionsmechanismen der Sprache werden auch für die Metainformationen genutzt (Klassen, Objekte, Methoden...) Erhalten der grundsätzlichen Struktur eines Programmes. 3 von 38

4 und Java "Eingebaute" Unterstützung durch Sprachkonstrukte JVM u. Classloader APIs Die verfügbaren Standardmechanismen Introspection: Bereitstellen von Informationen über eine Programmstruktur. Reflection: Dynamische Programmstrukturänderungen: Klassen, Datenzugriffe und Methodenaufrufe. Annotationen: Bereitstellen von deklarativen Zusatzinformationen im Code. Generics: Parametrisierung von Typen. 4 von 38

5 Introspection und Reflection 5 von 38

6 Die Rolle der Metaobjekte Die Zusammenhänge (Meta-)Informationen über elementare Datentypen, Arrays und Klassen sind auch zur Laufzeit verfügbar: Introspection. Sie werden von der JVM in Form von Instanzen zu Klassen aus dem Reflection-API bereitgestellt: Metaobjekte. Sie können auch für dynamische Zugriffe genutzt werden: Reflection (s. u.) Wesentliche Bestandteile 1. java.lang.class 2. Die Klassen des Pakets java.lang.reflect, insbesondere die Klassen Constructor, Field, Method, Array Man beachte: Der Einfluss von Generics auf das Reflection-API wird hier noch ausgeklammert (s. u.). 6 von 38

7 Die wichtigsten Klassen und Objekte 7 von 38

8 Die zentrale Klasse java.lang.class (1) Instanzen Zu jeder Klasse gibt es eine Instanz der Klasse java.lang.class, die alle Klasseninformationen enthält, bzw. referenziert (dito für Interfaces, einfache Datentypen, Arrays, void). D. h. jeder Java-Typ wird in der JVM durch ein Objekt repräsentiert. Dieses Objekt wird vom ClassLoader instanziiert. Man erhält es ausgehend von einer Instanz der repräsentierten Klasse mit der Methode getclass() (geerbt von der Klasse Object). Alternativ ist das Class-Objekt als Wert der Konstante <Typname>.class verfügbar. Methoden Die folgenden Methoden liefern Basis-Informationen über die Klasse und ihre Einbindung in die Klassenhierarchie: public String getname(), public boolean isinterface(), public boolean isarray(), public boolean isprimitive(), public int getmodifieres(), public Class getsuperclass(), public Class[] getinterfaces(), public Class getdeclaringclass() // falls die Klasse ein Member einer anderen Klasse ist 8 von 38

9 Die zentrale Klasse java.lang.class (2) Beispiel: Source-Code-Erzeugung per Reflection public class SourceReconstruct { private static void writeclassheader(class c) { String name = c.getname(); int i = name.lastindexof("."); if (i > -1) { // extract package name System.out.println("package "+ name.substring(0,i) + ";"); name = name.substring(i+1, name.length()); System.out.print(Modifier.toString(c.getModifiers()) + " "); System.out.print("class " + name + " "); Class superclass = c.getsuperclass(); if (superclass!= null) System.out.print("extends " + superclass.getname() + " "); Class[] interfaces = c.getinterfaces(); if (interfaces.length!= 0) { System.out.print("implements "); for (int j=0; ; j++) { System.out.print(interfaces[j].getName()); if (j == (interfaces.length -1)) break; else System.out.print(", "); public static void main(string[] args) { writeclassheader((new Double(2.1)).getClass()); writeclassheader(java.lang.class.class); writeclassheader(reflection.sourcereconstruct.class); // was liefern die folgenden "missbraeuchlichen" Verwendungen writeclassheader(int.class); writeclassheader(void.class); writeclassheader(int[].class); 9 von 38

10 Die zentrale Klasse java.lang.class (3) weitere Methoden Mit der Methode getclassloader() kann der Klassenlader ermittelt werden, der die Klasse geladen hat. Falls der Standard-Klassenlader verwendet wurde, wird null zurückgegeben. Die in der Klasse enthaltenen Members (Konstruktoren, Methoden, Felder, innere Klassen) bzw. die Modifizierer der Klasse können über getxxx()-methoden abgeholt werden. Es können auch gezielt die Objekte für einzelne Members aufgrund von Namen bzw. Signatur abgeholt werden, z. B. public Method getdeclaredmethod(string name,class[] parametertypes) throws NoSuchMethodException, SecurityException Zusätzliche Methoden in der Klasse Class dienen zum dynamischen Klassenladen und Instanziieren (s. u.). 10 von 38

11 Die restlichen Metaklassen Die Klasse java.lang.reflect.method Jeder Methode einer Klasse entspricht eine (von der JVM generierte) Instanz dieser Klasse mit Auskunftsmethoden über die deklarierende Klasse und die Bestandteile der Signatur Eine Methode zum Aufruf der repräsentierten Methode (s. u.). Die Klasse java.lang.reflect.field Jedem Feld einer Klasse entspricht eine (von der JVM generierte) Instanz dieser Klasse. Sie enthält Methoden zum Lesen und Setzen eines Memberwertes für ein übergebenes Objekt, welches das entsprechende Feld besitzt. Die Klasse java.lang.reflect.constructor Jedem Konstruktor einer Klasse entspricht eine (von der JVM generierte) Instanz dieser Klasse mit Auskunftsmethoden über die deklarierende Klasse und die Bestandteile der Signatur, einer Methode zum Instanziieren eines neuen Objekts mit diesem Konstruktor (s. u.). Die Klasse java.lang.reflect.modifier Modifizierer für Klassen und Members werden als int-konstanten verwaltet. Die Klasse Modifier enthält statische Konstanten und statische Methoden zum Interpretieren dieser int-werte. Die Klasse java.lang.reflect.array Diese Klasse enthält statische Methoden zum dynamischen Kreieren von belieben Arrays, sowie zum Setzen und Auslesen von Feldwerten. 11 von 38

12 Dynamisches Klassenladen Das Prinzip Klassen können auf Basis des Klassennamens geladen werden und anschließend instanziiert werden. Dabei braucht zur Compile-Zeit des instanziierenden Codes der Klassenname noch gar nicht bekannt sein. Die relevanten Methoden in der Klasse Class Die Methode public static Class forname(string classname) lokalisiert, lädt und bindet die Klasseninstanz zu dem übergebenen Klassennamen. (wirft gegebenenfalls ClassNotFoundException) Die Methode public Object newinstance()erzeugt eine neue Instanz zu einer gegebenen Klasse, die einen Default-Konstruktor besitzt. (wirft gegebenenfalls InstantiationException oder IllegalAccessException) 12 von 38

13 Beispiel: Dynamisches Klassenladen Beispiel public class DynamicStackLoad { public static void main(string[] args) { String classname = null; Class stackclass = null; Stack stackinstance = null; System.out.println("Which stack implementation do You want to use today?"); try { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); classname = reader.readline(); catch(ioexception ex) {... try { System.out.println("--> load " + classname); stackclass = Class.forName(className) System.out.println("--> instantiate " + stackclass); stackinstance = (Stack) stackclass.newinstance(); catch(classnotfoundexception ex) {... catch(instantiationexception ex) {... catch(illegalaccessexception ex) {... StackUsage.stackTest(stackInstance); 13 von 38

14 Dynamischer Methodenaufruf Beispiel import java.lang.reflect.*; class Tuer { public void doit(int i) { System.out.println("Ich (" + this + ") tu' was mit der Zahl: "+i); public class InvokeTest { public static void main(string[] args) { try { Class cl = Class.forName("reflection.Tuer"); Object obj = cl.newinstance(); // doit() with single int parameter Method method = cl.getdeclaredmethod("doit", new Class[]{int.class); method.invoke(obj, new Object[] { new Integer(3)); // call same method for another object method.invoke(new Tuer(), new Object[] { new Integer(6)); catch(classnotfoundexception ex) {... catch(instantiationexception ex) {... catch(nosuchmethodexception ex) {... catch(invocationtargetexception ex) {... catch(illegalaccessexception ex) {... Man beachte: 1. Sowohl Klasse als auch aufzurufende Methode (und deren Parameter) können zur Laufzeit festgelegt werden. 2. Analog zum dyn. Methodenaufruf kann ein Konstruktoraufruf (für anderen als Default-Konstruktor) erfolgen. 14 von 38

15 Wozu überhaupt Introspection und Reflection? Das Reflection-API ist immens wichtig im Kontext von diversen Frameworks, Serialisierung, Beans, RMI usw. 15 von 38

16 Annotationen 16 von 38

17 Annotationen: Die Quintessenz Zweck Zusätzliche Metainformationen, die nicht zur eigentlichen Logik des Programms gehören. Deklarativer Charakter: Name und ggf. Attribute Realisierung Können vor unterschiedlichen Programmelementen plaziert werden: Klasse, Methode, Attribut,... Eigene Auswertung zur Compilierzeit oder vorher zur Laufzeit Ein paar Anwendungsfelder Compilersteuerung Unit-Testing: Festlegen von Testmethoden u. ä. vor allem Frameworks im Enterprise-Bereich, z. B. Mapping von Objekten auf Datenbankinhalte 17 von 38

18 Vordefinierte Annotationen Die Typen Deprecated Override SuppressWarnings Auswertung durch den Compiler Beispiel public class AnnotatedClass extends BaseClass public void oldmethod() public void doit() { ; von 38

19 Selbstdefinierte Annotationen (1) Die Verwendung public class AnnotatedClass public void mymethod1() ("usage of this method is dangerous") public void mymethod2() ({"Alf", "Sally") public void mymethod3() (what="execute", count=3) public void mymethod4() = "Joe", last = "Hacker")) public void mymethod5() { von 38

20 Selbstdefinierte Annotationen (2) Die zugehörige Definitionen // simple annotation MyMarker { // annotation with one attribute MyComment { String value(); // marker with array of attributes Authors { String[] value(); 20 von 38

21 Selbstdefinierte Annotationen (3) // annotation with named attributes ToDo { String what(); int count() default 1; ; // reusable annotation Name { String first(); String last(); // complex annotation Reviewer { Name value(); 21 von 38

22 Meta-Annotationen (1) Einsatzzweck Annotation von Annotationsdefinitionen Die Typen Documented Aufnahme der markierten Annotation in das JavaDoc des annotierten Elementes Inhereted Markierte Annotation soll vererbt werden. Target Legt das (die) Elemente fest, an der die Annotation angebracht werden kann (Default: alle): TYPE FIELD METHOD, u. w. Retention Legt fest, wie lange Annotationen erhalten bleiben sollen (Default: CLASS): SOURCE CLASS RUNTIME 22 von 38

23 Meta-Annotationen ElementType.TYPE, ElementType.METHOD ToDo { String what(); int count(); 23 von 38

24 Verarbeitung von Annotationen Reflection-API zum Auslesen bei RetentionPolicy RUNTIME Beispiel: public class AnnotationsAnalyzer { public static void main(string[] args) { Class clazz = Class.forName("annotations.AnnotatedClass"); Annotation[] classannotations = clazz.getannotations();... Method[] methods = clazz.getmethods(); for (int i = 0; i < methods.length; i++) { Annotation[] methodannotations = methods[i].getannotations(); System.out.println(" method: " + methods[i].getname()); for (int j = 0; j < methodannotations.length; j++) { System.out.println(" annotation:" + methodannotations[j]); ToDo todo = methods[i].getannotation(todo.class); if (todo!= null) { System.out.println(" what: " + todo.what()); System.out.println(" count: " + todo.count()); 24 von 38

25 Generics 25 von 38

26 Generics: Die Quintessenz Absicht Typparametrisierung von Interfaces, Klassen und eigenständigen Methoden Codevervielfachung vermeiden: pro Familie von parametrisierten Elementen nur ein Source- und Byte-Code Dabei Typsicherheit (zur Compilierzeit) sicherstellen. Realisierung Betroffene Interfaces, Klassen und eigenständige Methoden erhalten bei der Definition einen (oder mehrere) formale Typparameter (Syntax, z. B.: <T>) Bei der Verwendung wird für den formalen Parameter ein aktueller Parameter eingesetzt (Syntax, z. B.: <String>). Auf Byte-Code-Ebene wird die Parametrisierung durch Verwendung der Klasse Object aufgelöst: Type-Erasure! Anwendung Container-Klassen (Collection-API, s. u.) generische Algorithmen (z. B. sortieren von...) u. v. m. 26 von 38

27 Beispiel: Generische Klasse (1) Die Definition public class SingleObjectHolder<E> { private E element; public void put(e element) { this.element = element; public E get() { return element; Die Verwendung SingleObjectHolder<String> stringholder = new SingleObjectHolder<String>(); stringholder.put("hallo"); String s = stringholder.get();... SingleObjectHolder<Integer> intholder = new SingleObjectHolder<Integer>(); intholder.put(5); int i = intholder.get();... SingleObjectHolder<char[]> chararrayholder = new SingleObjectHolder<char[]>(); chararrayholder.put(new char[]{'a','b','c'); char [] ca = chararrayholder.get(); 27 von 38

28 Beispiel: Generische Klasse (2) Die Realisierung im Byte-Code (nach Decompilierung) public class SingleObjectHolder { private Object element; // type erasure! public void put(object element) { this.element = element; public Object get() { return element; SingleObjectHolder stringholder = new SingleObjectHolder(); stringholder.put("hallo"); String s = (String)stringHolder.get(); // type retrieval SingleObjectHolder intholder = new SingleObjectHolder(); intholder.put(integer.valueof(5)); int i = ((Integer)intHolder.get()).intValue(); 28 von 38

29 The Diamond Im Beispiel SingleObjectHolder<String> stringholder = new SingleObjectHolder<>();... SingleObjectHolder<Integer> intholder = new SingleObjectHolder<>();... SingleObjectHolder<char[]> chararrayholder = new SingleObjectHolder<>(); Der Mechanismus Der aktuelle Typ beim Konstruktoraufruf kann vom Compiler aus dem Kontext ermittelt werden (type inference). Das spart Schreibarbeit. seit Java von 38

30 Beispiel: Eigenständige generische Methoden Die Definition public class SwapDemo { public static void print(final Object[] a) { // hier keine Generics noetig! for (int i=0; i< a.length; i++) System.out.print(a[i] + " "); public static <T> void swap(t[] a, int i, int j) { // hier auch nicht unbedingt T t = a[i]; a[i] = a[j]; a[j] = t; public static <T> T getlast(t[] a) { return a[a.length - 1]; // aber hier! Die Verwendung Float[] fa = {2.0f, 4.7f, 3.9f, 0.9f; print(fa); swap(fa, 1, 3); // implizite Ermittlung des aktuellen Typparameters SwapDemo. <Float> swap(fa, 0, 2); // explizite Vorgabe des aktuellen Typparameters String[] sa = {"hello", "boys", "and", "girls"; print(sa); swap(sa,1,3); String s = getlast(sa); 30 von 38

31 Wurzeln von Generics und Grenzen Historie Vorbild: vor allem Templates in C++ (vgl. auch C#) Generics wurden erst mit Java 5 eingeführt. Daher ein partiell "aufgesetztes" Konstrukt. Daraus ergeben sich bestimmte Konsequenzen. Einschränkungen Aktuelle Typparameter können nur von einem Objekttyp, nicht Primitiv-Typ sein (siehe aber Autoboxing). Ein formaler Typ-Parameter einer Klasse darf nicht bei der Def. von statischen Variablen verwendet werden. Von einem formalen Typ-Parameter kann keine Instanz erzeugt werden (per new). Es kann kein Array-Objekt (per new) erzeugt werden, dessen Komponententyp ein formaler Parameter ist. Es kann kein Array oder eine Array-Referenz mit Komponenten vom Typ einer formal oder aktuell parametrisierten Klasse erzeugt werden (außer Parameter ist vom Typ unbounded Wildcard?, s. u.) Erlaubt: SingleObjectHolder<?>[] a = new SingleObjectHolder<?>[3]; Ein formaler Typ-Parameter darf nicht als Operand im instanceof-operator vorkommen. 31 von 38

32 Einschränkungen: Beispiele // Folgendes geht nicht!!!!! // public static <T> T makeinstance() { // return new T(); // // Ausweg!?! public static <T> T makeinstance(class<t> clazz) { try { return clazz.newinstance();... // Aufruf: makeinstance(myclass.class) // Folgendes geht nicht!!!!! // public static <T> T[] resize(t[] a) { // T[] cl = new T[a.length + 1]; // return cl; // // Ausweg!?! public static <T> T[] resize(t[] a, Class<T> elementtype) { T[] cl = (T[]) Array.newInstance(elementType, a.length + 1); return cl; 32 von 38

33 Generics und Vererbung Muster für erlaubte Ableitungen class B<T> extends A class B extends A<String> class B<T> extends A<T> class B<T> extends A<String> analog: Interfaces Vorsicht Eine Ableitungssituation (und damit verbundener Polymorphismus) bei aktuellen Typparametern überträgt sich nicht auf die dadurch parametrisierten Klassen. Beispiel: SingleObjectHolder<Number> ist keine Basisklasse von SingleObjectHolder<Integer>, also kein Upcast möglich. 33 von 38

34 Wildcards (1) Unbounded Wildcards Verwendungsmöglichkeiten Als Typparameter einer Referenzvariable, um Referenzen auf beliebig aktuell parametrisierte generische Klassen zu halten. Beim Anlegen von Arrays mit parametrisierten Komponenten (s. o.) Beispiel: SingleObjectHolder<Integer> integerholder = new SingleObjectHolder<Integer>(); SingleObjectHolder rawtypeholder = integerholder; // warning SingleObjectHolder // is a raw type integerholder = rawtypeholder; // warning:... needs // unchecked conversion... SingleObjectHolder<?> unboundedwildcardholder = integerholder; // no warning integerholder = unboundedwildcardholder; // error!!!! 34 von 38

35 Wildcards (2) Upperbound Wildcards Beispiel: class SingleObjectHolder<T extends Number> Wirkung: Als aktueller Typparameter ist nur eine Klasse unterhalb einer festen Klasse möglich. Der formale Parameter kann implizit auf diese Basisklasse gecastet werden. Beim Type-Erasure wird für den formalen Typparameter die Basisklasse eingesetzt (nicht Object). komplexeres Beispiel class A<T extends B & I1 & I2 & I3> wobei B eine Klasse und I1,..., I3 Interfaces sind. 35 von 38

36 Wildcards (3) Lowerbound Wildcards Muster für das Einschränken eines Methodenparameters static void doit(b<? super Integer> b) sinnvolle Verwendungen siehe Collection-API 36 von 38

37 Generics und Reflection (1) Die Einflüsse auf die Metaklasse Class Die Klasse Class ist parametrisiert: Class<T>. Das Class-Literal.class liefert den exakten Typ zurück. Object.getClass() und Class.forName() liefert nur einen per Wildcard aktuell parametrisierten Typ zurück. Beispiele Class<String> stringclass = String.class; Class<?> clazz1 = "abc".getclass(); Class<?> clazz2 = Class.forName("java.lang.String"); 37 von 38

38 Generics und Reflection (2) Was überlebt beim Type-Erasure? Ein Beispiel: public class GenericIntrospection { public static void main(string[] args) { Class<?>[] typevariables = = SingleObjectHolder.class; System.out.println(clazz); TypeVariable<?>[] typevariables = clazz.gettypeparameters(); for (int j = 0; j < typevariables.length; j++) System.out.println(typeVariables[j]); try { Method method = clazz.getdeclaredmethod("get", new Class[] {); System.out.println(method.getGenericReturnType()); method = clazz.getdeclaredmethod("put", new Class[] { Object.class ); System.out.println(method.getGenericParameterTypes()[0]); catch (NoSuchMethodException SecurityException e) { e.printstacktrace(); 38 von 38