1 / 20

A Small Extension to Java for Class Refinement

This paper presents a novel approach to class refinement in Java, introducing the GluonJ language, which allows for both static and dynamic class modifications without altering the original source code. By extending existing classes and using annotations, developers can refine behaviors at runtime effectively, thereby promoting software evolution. Key features include manageable runtime type errors and seamless integration into existing Java IDEs. This method ensures type safety and extends functionality while alerting developers to potential issues in a controlled manner.

cooper
Télécharger la présentation

A Small Extension to Java for Class Refinement

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. A Small Extension to Java for Class Refinement Muga Nishizawa and Shigeru Chiba (Tokyo Institute of Technology, Japan) ACM SAC'08, March 18, 2008

  2. Class Refinement for Software Evolution • Extend an existing class without modifying its source code class Point { int x, y; void setX(intnx) { x = nx; } void setY(intny) { y = ny; } } refine Point { void setX(int x) { System.out.println(“x :” + x); super.setX(x); } void print() { System.out.println(x + “, “ + y); } } ACM SAC'08, March 18, 2008

  3. Dynamic Class Refinement • Turn refinement on and off during runtime class WebApp { static Session context; String price(intitemNo) { .. } : } refine WebApp when context.lang == “jp” { String price(intitemNo) { return toYen(super.price(itemNo)) + “ yen”; } } ACM SAC'08, March 18, 2008

  4. The GluonJ Language • Static/dynamic class refinement for Java • Design goals • A normal Java syntax + Java annotations • No new language syntax • Programming with a normal Java IDE + compiler • Manageable runtime type errors • Runtime type errors should occur at only limited places • Compile-time type checking to a certain degree ACM SAC'08, March 18, 2008

  5. Manageable Runtime Type Errors • Without this, dynamic-refinement causes runtime type errors at too many places This causes a type error If Main.debug is false. class Point { int x, y; intsetX(intnx) { x = nx; } } Point p = … ; p.add(new Observer()); p.setX(0); p.print(); appended. refine Point whenMain.debug { void print() { … } List observer; void add(Observer o) { .. } void notify() { .. } void setX(intny) { notify(); … } } ACM SAC'08, March 18, 2008

  6. Syntax of GluonJ • It is described as a subclass of the original class. @Glue class Logging { @Refine static class BookLoggerextends Book { @Override intgetPrice() { System.out.println(price); return super.getPrice(); } } } The @Refine class refines a Book class. An @Glue class groups @Refine classes related to each other Indicates the Book class ACM SAC'08, March 18, 2008

  7. Calling an Appended Method • To call a newly appended method, an instance of its target class must be cast Book b = …; ((BookPrinter)b).print(); From the type of an original class to the type of an @Refine class @Glue class Printing { @Refine static class BookPrinter extends Book { void print() { System.out.println(“book[“ + title + “,” + price + “]”); } } } ACM SAC'08, March 18, 2008

  8. Bytecode Instrumentation • A class refinement is directly applied to the bytecode of the original class definition. class Book { intgetPrice() { System.out.println(price); return orig_getPrice(); } intorig_getPrice() { return price; } } Overridden by @Refine super.getPrice() is replaced The original getPrice() is renamed. ACM SAC'08, March 18, 2008

  9. Programming with a Java IDE • An @Refine class is a standard subclass • Enjoy a code assist by a Java IDE • A Java IDE recognizes methods/fields appended by @Refine classes Appended by a class refinement ACM SAC'08, March 18, 2008

  10. Dynamic-Refinement • Effective while the specified method is running. • Methods/fields are appended to all instances of the target class during that time. Print() is appended onlywhile getBookPrice() is running. @Cflow(“void BookStore.getBookPrice(Book)”) @Glue class CflowPrinting { @Refine static class BookPrinterextends Book { void print() { System.out.println(“book[“ + title + “,” + price + “]”); } } } ACM SAC'08, March 18, 2008

  11. No NoSuchMethodErrorthrown • For manageable type errors • Only explicit type casts may throw a type error. Never throws a type error May throw a type error class Point { int x, y; intsetX(intnx) { x = nx; } } Point p = … ; PointExpe = (PointEx)p; pe.add(new Observer()); pe.setX(0); pe.print(); refine PointExwhenMain.debug { void print() { … } List observer; void add(Observer o) { .. } void notify() { .. } void setX(intny) { notify(); … } } ACM SAC'08, March 18, 2008

  12. Bytecode instrumentation (again) • All methods/fields in an @Refine class are appended. • Cast opeartor • Before type cast, insert a code for checking whether or not the @Refine class is effective. • replace all occurrences of the type name of refinement classes with their target class names. • Methods • Throw NoSuchMethodError if the @Cflow condition is not satisfied. ACM SAC'08, March 18, 2008

  13. Coding constraints • For manageable type errors • Once an explicit type cast succeeds, a type error never happens • because the @Refine class is effective during the lifetime of the value. • The value never escapes from the dynamic scope where the @Refine class is effective. • Constraints • The value after the type cast cannot be savedin a non-local storage such as a field. • This is statically checked. ACM SAC'08, March 18, 2008

  14. Coding Constraints (cont.) • 1. A field of the type R appears only within G. • 2. The type R is not the return type or one of the parameter types of the method specified as the argument to @Cflow. • 3. R is not an exception type (i.e. a subclass of Throwable). It is not the parameter to a catch clause. • 4. The refinement class R does not override a static method in its original class. Let G is an @Glue class associated with @Cflowand let G include a @Refine class R ACM SAC'08, March 18, 2008

  15. Related Work • Class Refinement • E.g. eJava [Warth’06], AspectJ [Kiczales’01] • ContextJ [Costanza’06], CaesarJ [Aracic’06] • Extended Java languages • AspectJ5, JBoss AOP, AspectWerkz • Ad-hoc design with Java annotations • Thus such extensions are not understood by a normal Java IDE ACM SAC'08, March 18, 2008

  16. Conclusion • GluonJ • Static/dynamic class refinement for Java • Class refinement is useful for software evolution • The Design goals of GluonJ • A normal Java syntax + Java annotations • No new language syntax • Programming with a normal Java IDE + compiler • Manageable runtime type errors • Runtime type errors should occur at only limited places • Compile-time type checking to a certain degree ACM SAC'08, March 18, 2008

  17. Thank you ACM SAC'08, March 18, 2008

  18. Class Refinement • An effective technology for software evolution • Its concept is similar to subclassing, mixins • It allows separating an extension to a class as a module • E.g. • Changing an existing method in its class • Adding new methods, fields, interfaces to an existing class ACM SAC'08, March 18, 2008

  19. The Benefit of Refinement • Unlike subclassing and mixins, it directly modifies the definition of a class • Editing an original source code is NOT necessary • A client does not need to explicitly create an instance of the extended version of that class Refinement Subclassing directly modify class A class A class SubA A refinement for A A a = new SubA(); A a = new A(); ACM SAC'08, March 18, 2008

  20. Various Refinements • Static-refinement • It allows statically changing the structure of a class • E.g. eJava [Warth’06], AspectJ [Kiczales’01] • E.g. ContextJ [Costanza’06], CaesarJ [Aracic’06] • Dynamic-refinement • It allows switching refinements to a class according to dynamic contexts • These features are useful for modularly extending and customizing a program ACM SAC'08, March 18, 2008

More Related