Metamodelling and Metaprogramming

Transcription

1 Software aus Komponenten (Component-Based Software, CBSE) SS 2004 Exercise Sheet No. 1 Prof. Dr. rer. nat. U. Aßmann TU Dresden Lehrstuhl Softwaretechnologie The electronic version of this exercise sheet is available under TDDBC18. Metamodelling and Metaprogramming Task 1: Reflection in Java (9 Points) 1a) (3 pt.) Task: Write a program that reads the name of a class from the command line and emits the interface of the class in Java syntax (interface or class, modifiers, constructors, methods, fields, empty method bodies). Also use the program for itself. Hints: Load a class with java.lang.class.forname(). Solution: The class is: /** * InterfaceDumper.java */ import java.lang.reflect.*; import java.io.printstream; public class InterfaceDumper { /** The output stream */ private PrintStream out; /** Create a new signature dumper */ public InterfaceDumper() { out = System.out; /** Set an alternative output stream (Default: System.out) */ public void setprintstream(printstream p) { out = p; /** Dump a class signature to the output stream */ public void dump(class c) { boolean isaninterface = c.isinterface(); 1

2 String interfaceinheritanceclause = ""; // dump class or interface if (isaninterface) { out.print("interface "); interfaceinheritanceclause = "extends "; else { out.print("class "); interfaceinheritanceclause = "implements "; // dump name: out.println(c.getname()); // dump modifiers: out.println("modifiers: "+ Modifier.toString(c.getModifiers())); // dump inheritance relations Class sc = c.getsuperclass(); if(sc!= null && sc!= Object.class) out.println("extends " + sc.getname()); Class[] ifs = c.getinterfaces(); if(ifs.length > 0) { out.print(interfaceinheritanceclause); for(int i = 0; i < ifs.length; i++) { if(i!= 0) out.print(", "); out.print(ifs[i].getname()); // dump class body: constructors, methods, fields out.println(" {"); out.println(" // Constructors"); Constructor[] cs = c.getdeclaredconstructors(); for(int i = 0; i < cs.length; i++) dump(cs[i]); out.println(""); out.println(" // Methods"); Method[] ms = c.getdeclaredmethods(); for(int i = 0; i < ms.length; i++) dump(ms[i]); out.println(""); out.println(" // Fields"); Field[] fs = c.getdeclaredfields(); for(int i = 0; i < fs.length; i++) dump(fs[i]); out.println(""); 2

3 out.println(""); /** Dump a constructor signature to the output stream */ public void dump(constructor c) { out.println(" " + c.tostring() + ";"); /** Dump a method signature to the output stream */ public void dump(method m) { out.println(" " + m.tostring() + ";"); /** Dump a field signature to the output stream */ public void dump(field f) { out.println(" " + f.tostring() + ";"); public static void main(string[] argv) throws Throwable { InterfaceDumper id = new InterfaceDumper(); for(int i = 0; i < argv.length; i++) { Class c = Class.forName(argv[i]); id.dump(c); Here follows a test input: interface TestSuperI { int getcontent(); void setcontent(int val); interface TestI extends TestSuperI { void changecontent(); abstract class TestSuper implements TestI { protected int content; protected TestSuper() { content = 0; public int getcontent() { return content; public void setcontent(int val) { content = val; abstract public void changecontent(); 3

4 public class InterfaceTest extends TestSuper implements TestI { public void changecontent() { content += 42; Can be called as java InterfaceDumper InterfaceDumper 1b) (3 pt.) Task: Now write a program that reads a class name, reads a list of arguments from the command line, and creates an object of that class with the read arguments. Treat arguments as strings. A java.lang.class can enumerate its constructors. Choose a constructor with the appropriate parameter count. Then, find the parameter types. To create typed argument objects, call the appropriate constructors that take a string as arguments. Call dynamic constructors by java.lang.reflect.constructor.newinstance(). Solution: /** * DynamicConstructor.java * */ import java.lang.reflect.*; public class DynamicConstructor { protected Class c; /** create a new dynamic constructor for the given class */ public DynamicConstructor(Class c) { this.c = c; /** invoke the constructor with the given arguments dynamically */ public Object newinstance(string[] args) throws Throwable { Constructor[] cs = c.getconstructors(); for(int i = 0; i < cs.length; i++) { Constructor co = cs[i]; Class[] params = co.getparametertypes(); if(params.length == args.length) { Object[] typedargs = convertargs(args, params); return co.newinstance(typedargs); throw new RuntimeException("No suitable constructor found:" + c.getname()); 4

5 /** convert the string arguments to parameter types */ Object[] convertargs(string[] args, Class[] paramtypes) throws Throwable { Object[] res = new Object[args.length]; for(int i = 0; i < args.length; i++) res[i] = convertarg(args[i], paramtypes[i]); return res; /** convert a string argument to parameter types */ Object convertarg(string arg, Class paramtype) throws Throwable { // conversion necessary? if(paramtype.isinstance(arg)) return arg; // find suitable constructor and convert. Constructor[] cs = paramtype.getconstructors(); for(int i = 0; i < cs.length; i++) { Constructor co = cs[i]; Class[] params = co.getparametertypes(); if(params.length == 1) { if (params[0].equals(string.class)) { Object[] args = {arg; return co.newinstance(args); if (paramtype.equals(class.class)) return Class.forName(arg); throw new RuntimeException("No suitable constructor found:" + c.getname()); public static void main(string argv[]) throws Throwable { // parse input Class c = Class.forName(argv[0]); String[] cargs = new String[argv.length-1]; System.arraycopy(argv, 1, cargs, 0, argv.length-1); // invoke constructor DynamicConstructor co = new DynamicConstructor(c); Object o = co.newinstance(cargs); System.out.println("Object: " + o); The test input could be: public class ConstructorTest { private int x; private double y; private String z; public ConstructorTest(Integer x) { this(x, new Double(0.0), "leer"); 5

6 public ConstructorTest(Integer x, Double y) { this(x,y,"leer"); public ConstructorTest(Integer x, Double y, String z) { this.x = x.intvalue(); this.y = y.doublevalue(); this.z = z; public String tostring() { return "x = " + x + ", y = " + y + ", z = " + z; The class should be called as java DynamicConstructor ConstructorTest 42 1c) (3 pt.) Task: Extend the solution of the previous task by reading a method name and a list of method arguments. Call the method on a newly created object dynamically. Also call the solution of subtask (a) to emit the interfaces of your solution. Hint: java.lang.class can enumerate its methods. java.lang.reflect.method.invoke() can call methods dynamically. Solution: /** * DynamicInvoker.java * */ import java.lang.reflect.*; public class DynamicInvoker extends DynamicConstructor { /** create a new dynamic invoker for the given object */ public DynamicInvoker(Class c) { super(c); /** invoke the method with the given arguments dynamically */ public Object invoke(object o, String name, String[] args) throws Throwable { Method[] ms = c.getmethods(); for(int i = 0; i < ms.length; i++) { Method m = ms[i]; String n = m.getname(); Class[] params = m.getparametertypes(); if(name.equals(n) && params.length == args.length) { Object[] typedargs = convertargs(args,params); 6

7 return m.invoke(o,typedargs); throw new RuntimeException("No suitable method found:" + c.getname() + "." + name + "()"); public static void main(string argv[]) throws Throwable { // parse input Class c = Class.forName(argv[0]); // determine number of constructor arguments int i = 1; while(!argv[i].equals("-")) i++; // get constructor arguments String[] cargs = new String[i-1]; System.arraycopy(argv,1,cArgs,0,i-1); // get method name String mname = argv[i+1]; // get method arguments String[] margs=new String[argv.length-i-2]; System.arraycopy(argv,i+2,mArgs,0,argv.length-i-2); // invoke constructor DynamicInvoker di = new DynamicInvoker(c); Object o = di.newinstance(cargs); System.out.println("Object: " + o); System.err.println("Invoking method " + mname + " with args " + margs); // invoke method Object res = di.invoke(o, mname, margs); System.out.println("Result: " + res); System.out.println("Object: " + o); Should be called as java DynamicInvoker InterfaceDumper - dump DynamicInvoker Task 2: Basic Definitions of Component Systems (8 Points) 2a) (1 pt.) Task: Define the notion Object. Solution: Objects incorporate both data structure and behaviour. They generally include four aspects: identity, classification, polymorphism, and inheritance (Rumbaugh, et.al.). 7

8 2b) (1 pt.) Task: Define the notion Class. Solution: A class is a modellig item that describes important properties of an application and ignores the rest. It describes a possibly infinite set of individual objects (Rumbaugh, et.al.). 2c) (1 pt.) Task: Define the notion Module. Solution: Every module hides an important design decision behind a well-defined interface which does not change when the decision changes (Parnas). 2d) (1 pt.) Task: Define the notion Type. Solution: A type system is a tractable syntacic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute (Pierce). 2e) (1 pt.) Task: Define the notion Component. Solution: A component is a unit for composition (Folklore). 2f) (1 pt.) Task: Define the notion creation of a component. Solution: Instantiating a component from a template or pattern. Corresponds to the instantiation of a class to an object. 2g) (1 pt.) Task: Define the notion parameterization of a generic component. Solution: Similarly to the parameterization of a generic class, but may be on a different abstraction level. 2h) (1 pt.) Task: Discuss: Is a generic class a class. Solution: No. The parameterized generic class is a class; the generic class is a template. Task 3: Open and Closed Forms of Components (4 Points) Consider the following Java package hierarchy. package a; public class A {.. ; package a.b; public class A {.. ; package a.b.d; public class A {.. ; package a.c; public class B {.. ; 8

9 3a) (1 pt.) Task: How is the part-of relation expressed in Java packages? Solution: By nesting of the package names and the nesting of their corresponding directories. 3b) (2 pt.) Task: Produce a file with all classes (in one package). What do you have to do with the class names? How is the part-of relationship expressed now? Solution: You have to rename the classes with their packages as prefix. package a; public class a.a {.. ; public class a.b.a {.. ; public class a.b.d.a {.. ; public class a.c.b {.. ; The part-of relationship is now expressed by a structured naming scheme. 3c) (1 pt.) Task: Why are directory hierarchies simple component systems? Solution: Because they express a part-of relationship. Task 4: Knowledge Metaprogramming (8 Points) 4a) (3 pt.) Task: Enumerate and explain several times in system construction. Solution: system generation time. compilation time link time. allocation time. run time reconfiguration time recomposition time 4b) (3 pt.) Task: Explain the difference between static and dynamic metaprogramming. Solution: Dynamic metaprogramming involves runtime generation of code, followed by its evaluation. Static metaprograming generates code at compile time (or before compile, at system generation time) and removes all metaprograms before run time. 4c) (2 pt.) Task: What is the difference between reflection in Java and dynamic metaprogramming? Solution: Java reflection is a restricted form of dynamic metaprogramming. Methods can be compiled and loaded, but there is no metamodel of program elements within a method (no statements, no expressions). 9