Attribute-Based Component Programming System and Methodology for Object-Oriented Languages

• US 20050216885A1
• Filed: 06/04/2004
• Published: 09/29/2005
• Est. Priority Date: 03/29/2004
• Status: Active Grant

• Current Assignee: Sybase Incorporated (SAP SE)
• Original Assignee: Sybase Incorporated (SAP SE)
• Inventors: Ireland, Evan P.
• Granted Patent: US 8,291,375 B2
• Time in Patent Office: Days
• US Class Current: 717/108
• CPC Class Codes: G06F 8/00 Arrangements for software engineering testing or debugging G06F11/36; administrative, planning or organisation aspects of software project management G06Q10/06
• CPC Class Codes: G06F 9/4488 Object-oriented

Abstract

An attribute-based component programming system and methodology for object-oriented languages is described. In one embodiment, for example, a method is described for dynamically generating program code adding behavior to a program based on attributes, the method comprises steps of: adding a component object to a program class of the program to create a component; defining at least one attribute specifying declaratively behavior to be added to the program; associating the at least one attribute with the component; and in response to instantiation of the component at runtime, generating a subclass based on the program class and the at least one attribute, the subclass including dynamically generated program code based on the at least one attribute.

Claims

1. A method for dynamically generating program code adding behavior to a program based on attributes, the method comprising:

adding a component object to a program class of the program to create a component;

defining at least one attribute specifying declaratively behavior to be added to the program;

associating said at least one attribute with the component; and

in response to instantiation of the component at runtime, generating a subclass based on the program class and said at least one attribute, the subclass including dynamically generated program code based on said at least one attribute.

2. The method of claim 1, wherein said defining step includes defining a particular attribute using active metadata, so as to provide a mechanism for generation of program code from said particular attribute.

3. The method of claim 2, wherein said active metadata dynamically generates code for inclusion in a subclass based on the program class.

4. The method of claim 1, wherein the generating step includes generating a subclass comprising an instance of a declared component class.

5. The method of claim 1, wherein the generating step includes generating a subclass comprising an instance of an abstract component class.

6. The method of claim 1, wherein said defining step includes defining at least one attribute based on comments in source code of the program class.

7. The method of claim 6, further comprising:

precompiling a class containing static attributes from said comments.

8. The method of claim 7, further comprising:

loading the class containing static attributes before subclass generation when a component is instantiated.

9. The method of claim 6, further comprising:

defining an automated mapping between attribute syntax in comments and attribute syntax as expressed in generated program code.

10. The method of claim 1, wherein said defining step includes defining at least one attribute in a property file external to the program class.

11. The method of claim 10, further comprising:

compiling a class containing dynamic attributes from said property file.

12. The method of claim 11, further comprising:

loading the class containing dynamic attributes before subclass generation when a component is instantiated.

13. The method of claim 10, further comprising:

defining an automated mapping between attribute syntax in a property file and attribute syntax as expressed in generated program code.

14. The method of claim 10, wherein attributes in the property file comprise property name and property value pairs.

15. The method of claim 1, wherein said defining step includes defining attributes for a superclass from which the program class inherits.

16. The method of claim 1, wherein said defining step includes defining attributes for the program class'"'"' package from which the program class inherits.

17. The method of claim 1, wherein said defining step includes defining attributes for an interface from which the program class inherits.

18. The method of claim 17, wherein said generating step includes generating an instance of a subclass to mock the behavior of the interface.

19. The method of claim 1, wherein said generating step includes generating code for a non-abstract method body based on an attribute defined for an abstract method.

20. The method of claim 1, wherein said generating step includes generating program code based on comments in a source file.

21. The method of claim 1, further comprising:

adding expected calls as instances of anonymous inner classes of the program; and

applying runtime introspection by a generated subclass to verify a sequence of expected calls.

22. The method of claim 1, wherein the component registers itself with a repository when the component is initially activated.

23. The method of claim 22, wherein the repository can be queried to determine components that are active.

24. A computer-readable medium having processor-executable instructions for performing the method of claim 1.

25. A downloadable set of processor-executable instructions for performing the method of claim 1.

26. A system for dynamically generating program code based on declarative attributes, the system comprising:

a component module for creating a component from a program class based on adding a component object to the program class;

an attribute module for defining at least one declarative attribute specifying behavior to be added to the program class and associating said at least one attribute with the component; and

a module for generating a subclass of the program class in response to instantiation of the component, the subclass including dynamically generated program code based on said at least one declarative attribute.

27. The system of claim 26, wherein the subclass adds tracing behavior to a program.

28. The system of claim 26, wherein the subclass is a subclass of an abstract class.

29. The system of claim 26, wherein said at least one declarative attribute includes active metadata, so as to provide a mechanism for generation of program code.

30. The system of claim 29, wherein said active metadata dynamically generates code for inclusion in the subclass of the program class.

31. The system of claim 26, wherein the attribute module provides for defining at least one attribute based on comments in source code of the program class.

32. The system of claim 31, further comprising:

a precompiler for precompiling a class containing static attributes from said comments.

33. The system of claim 32, wherein the module for generating loads the class containing static attributes before subclass generation.

34. The system of claim 31, further comprising:

an automated mapping between attribute syntax in comments and attribute syntax as expressed in generated program code.

35. The system of claim 26, wherein the attributed module provides for defining at least one attribute in a property file external to the program class.

36. The system of claim 35, further comprising:

a module for compiling a class containing dynamic attributes from said property file.

37. The system of claim 36, wherein the module for generating loads the class containing dynamic attributes before subclass generation when a component is instantiated.

38. The system of claim 35, further comprising:

an automated mapping between attribute syntax in a property file and attribute syntax as expressed in generated program code.

39. The system of claim 35, wherein attributes in a property file comprise property name and property value pairs.

40. The system of claim 26, wherein the attribute module provides for defining attributes for a superclass from which the program class inherits.

41. The system of claim 26, wherein the attribute module for provides for defining attributes for an interface from which the program class inherits.

42. The system of claim 41, wherein the module for generating generates an instance of a subclass to mock the behavior of the interface.

43. The system of claim 26, wherein the module for generating generates code for a non-abstract system body based on an attribute defined for an abstract method.

44. The system of claim 26, wherein the module for generating includes generating program code based on comments in a source file.

45. The system of claim 26, wherein the component registers itself with a repository when the component is initially activated.

46. The system of claim 45, wherein the repository can be queried to determine components that are active.

47. A method for adding behavior to an application without access to application source code, the method comprising:

defining at least one attribute specifying declaratively behavior which is desired to be added to an application without access to the application source code;

storing said at least one attribute in a properties file external to the application;

creating a dynamic attributes class based on the properties file;

compiling the application and the dynamic attributes class; and

generating a subclass which includes dynamically generated code adding behavior to application based on said at least one attribute.

48. The method of claim 47, wherein said defining step includes defining a particular attribute using active metadata, so as to provide a mechanism for generation of program code from said particular attribute.

49. The method of claim 48, wherein said active metadata dynamically generates code for inclusion in the subclass.

50. The method of claim 47, wherein said defining step includes defining an attribute for overriding a method of the application.

51. The method of claim 47, wherein said defining step includes defining an attribute for extending a method of the application.

52. The method of claim 47, further comprising:

loading the class containing dynamic attributes before generating the subclass.

53. The method of claim 47, further comprising:

defining an automated mapping between attribute syntax in the properties file and attribute syntax as expressed in generated program code.

54. The method of claim 47, wherein said at least one attribute in the properties file comprise property name and property value pairs.

55. The method of claim 47, wherein said creating step includes creating a dynamic attributes class using a precompiler.

56. The method of claim 47, wherein said creating step includes creating a dynamic attributes class at runtime.

57. The method of claim 47, wherein said compiling step includes using a Java compiler (JAVAC).

58. The method of claim 47, wherein said generating step includes using a precompiler.

59. The method of claim 47, wherein said generating step includes using a runtime compiler.

60. A computer-readable medium having processor-executable instructions for performing the method of claim 47.

61. A downloadable set of processor-executable instructions for performing the method of claim 47.