Methods and Apparatus for Dynamic Class Reloading and Versioning

• US 20100199259A1
• Filed: 01/30/2009
• Published: 08/05/2010
• Est. Priority Date: 01/30/2009
• Status: Active Grant

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Oracle America, Inc. (Oracle Corporation)
• Inventors: Quinn, Timothy J., Rose, John R.
• Granted Patent: US 8,612,930 B2
• Time in Patent Office: Days
• US Class Current: 717/106
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
• CPC Class Codes: G06F 9/44536 Selecting among different versions

Abstract

Methods and apparatus for dynamic class reloading and versioning that allow developers to change and recompile classes and to have running programs adopt the new versions of the classes dynamically, without redeploying the application. A dynamic class reloading component detects if the environment supports dynamic class redefinition and uses it if supported but does not require it. As the component loads a managed class, it modifies the bytecode of the class and generates additional classes and interfaces to support type-safe class versioning. Unique names are generated for successive versions of a managed class. A separate interface may be generated for each distinct method name and signature implemented on managed classes. Each generated class may implement all the generated interfaces that correspond to its methods. The same class loader that would load each managed class without the component loads the component-generated classes and interfaces.

Claims

1. A system, comprising:

at least one processor; and

a memory storing program instructions executable by the at least one processor to implement a dynamic class reloading component configured to;

determine that a previously loaded version of a class is not current with a class definition of the class in a class file;

generate a new version of a body class for the class and a new version of a static body class for the class using bytecode from the class file, wherein the new versions of the body class and the static body class are given unique names;

generate an instance of the new version of the static body class and set a static body class field of the class to refer to the instance of the new version of the static body class;

for each existing instance of the class, generate an instance of the new version of the body class and set a body class field of the existing instance of the class to the corresponding instance of the new version of the body class; and

load a new version of the class corresponding to the class definition of the class in the class file via a class loader for the class.

2. The system as recited in claim 1, wherein, after said determine that a previously loaded version of a class is not current with a class definition of the class in a class file, the dynamic class reloading component is further configured to record date/time information for the class file corresponding to the class.

3. The system as recited in claim 1, wherein, after said determine that a previously loaded version of a class is not current with a class definition of the class in a class file, the dynamic class reloading component is further configured to generate an interface for each method of the class for which an interface has not previously been generated.

4. The system as recited in claim 1, wherein the dynamic class reloading component is configured to load an initial version of the class prior to said determine that a previously loaded version of the class is not current with the class definition of the class in the class file, wherein, to load an initial version of the class, the dynamic class reloading component is configured to:

record date/time information for the class file corresponding to the class;

generate an interface for each method of the class;

generate an initial version of the body class and an initial version of the static body class using bytecode from the class file, wherein the body class and the static body class are given unique initial names;

transform bytecode of the class; and

load the initial version of the class via the class loader for the class.

5. The system as recited in claim 4, wherein, to transform bytecode of the class, the dynamic class reloading component is configured to:

add the static body class field to the class and initialize the static body class field to refer to an instance of the initial version of the static body class;

add the body class field to the class;

alter the bytecode for each static method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current static body class cast to the interface which the dynamic class reloading component generated for that method;

alter the bytecode for each instance method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current body class cast to the interface which the dynamic class reloading component generated for that method; and

alter the bytecode at each place that a method on a different class managed by the dynamic class reloading component is invoked to check that the currently loaded instance of the different class is up-to-date with respect to the class file for the different class.

6. The system as recited in claim 1, wherein the dynamic class reloading component is configured to determine that a previously loaded version of a class is not current with a class definition of the class in a class file in response to an invocation of a method of the previously loaded instance of the class.

7. The system as recited in claim 1, wherein, to determine that a previously loaded version of a class is not current with a class definition of the class in a class file, the dynamic class reloading component is configured to determine that the previously loaded version of the class was loaded prior to a last modified time of the class file.

8. A computer-implemented method, comprising:

determining that a previously loaded version of a class is not current with a class definition of the class in a class file;

generating a new version of a body class for the class and a new version of a static body class for the class using bytecode from the class file, wherein the new versions of the body class and the static body class are given unique names;

generating an instance of the new version of the static body class and setting a static body class field of the class to refer to the instance of the new version of the static body class;

for each existing instance of the class, generating an instance of the new version of the body class and setting a body class field of the existing instance of the class to the corresponding instance of the new version of the body class; and

loading a new version of the class corresponding to the class definition of the class in the class file via a class loader for the class.

9. The computer-implemented method as recited in claim 8, wherein, after said determining that a previously loaded version of a class is not current with a class definition of the class in a class file, the method further comprises recording date/time information for the class file corresponding to the class.

10. The computer-implemented method as recited in claim 8, wherein, after said determining that a previously loaded version of a class is not current with a class definition of the class in a class file, the method further comprises generating an interface for each method of the class for which an interface has not previously been generated.

11. The computer-implemented method as recited in claim 8, further comprising loading an initial version of the class prior to said determining that a previously loaded version of the class is not current with the class definition of the class in the class file, wherein, said loading an initial version of the class comprises:

recording date/time information for the class file corresponding to the class;

generating an interface for each method of the class;

generating an initial version of the body class and an initial version of the static body class using bytecode from the class file, wherein the body class and the static body class are given unique initial names;

transforming bytecode of the class; and

loading the initial version of the class via the class loader for the class.

12. The computer-implemented method as recited in claim 11, wherein said transforming bytecode of the class comprises:

adding the static body class field to the class and initialize the static body class field to refer to an instance of the initial version of the static body class;

adding the body class field to the class;

altering the bytecode for each static method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current static body class cast to the interface which the dynamic class reloading component generated for that method;

altering the bytecode for each instance method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current body class cast to the interface which the dynamic class reloading component generated for that method; and

altering the bytecode at each place that a method on a different class managed by the dynamic class reloading component is invoked to check that the currently loaded instance of the different class is up-to-date with respect to the class file for the different class.

13. The computer-implemented method as recited in claim 8, further comprising determining that a previously loaded version of a class is not current with a class definition of the class in a class file in response to an invocation of a method of the previously loaded instance of the class.

14. The computer-implemented method as recited in claim 8, wherein said determining that a previously loaded version of a class is not current with a class definition of the class in a class file comprises determining that the previously loaded version of the class was loaded prior to a last modified time of the class file.

15. A computer-readable storage medium storing program instructions, wherein the program instructions are computer-executable to implement:

determining that a previously loaded version of a class is not current with a class definition of the class in a class file;

generating a new version of a body class for the class and a new version of a static body class for the class using bytecode from the class file, wherein the new versions of the body class and the static body class are given unique names;

generating an instance of the new version of the static body class and setting a static body class field of the class to refer to the instance of the new version of the static body class;

for each existing instance of the class, generating an instance of the new version of the body class and setting a body class field of the existing instance of the class to the corresponding instance of the new version of the body class; and

loading a new version of the class corresponding to the class definition of the class in the class file via a class loader for the class.

16. The computer-readable storage medium as recited in claim 15, wherein, after said determining that a previously loaded version of a class is not current with a class definition of the class in a class file, the program instructions are computer-executable to implement recording date/time information for the class file corresponding to the class.

17. The computer-readable storage medium as recited in claim 15, wherein, after said determining that a previously loaded version of a class is not current with a class definition of the class in a class file, the program instructions are computer-executable to implement generating an interface for each method of the class for which an interface has not previously been generated.

18. The computer-readable storage medium as recited in claim 15, wherein the program instructions are computer-executable to implement loading an initial version of the class prior to said determining that a previously loaded version of the class is not current with the class definition of the class in the class file, wherein, in said loading an initial version of the class, the program instructions are computer-executable to implement:

recording date/time information for the class file corresponding to the class;

generating an interface for each method of the class;

generating an initial version of the body class and an initial version of the static body class using bytecode from the class file, wherein the body class and the static body class are given unique initial names;

transforming bytecode of the class; and

loading the initial version of the class via the class loader for the class.

19. The computer-readable storage medium as recited in claim 18, wherein, in said transforming bytecode of the class, the program instructions are computer-executable to implement:

adding the static body class field to the class and initialize the static body class field to refer to an instance of the initial version of the static body class;

adding the body class field to the class;

altering the bytecode for each static method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current static body class cast to the interface which the dynamic class reloading component generated for that method;

altering the bytecode for each instance method to check that the body class and the static body class are up-to-date with respect to the class file for the class and to delegate to the same-named instance method on the current body class cast to the interface which the dynamic class reloading component generated for that method; and

altering the bytecode at each place that a method on a different class managed by the dynamic class reloading component is invoked to check that the currently loaded instance of the different class is up-to-date with respect to the class file for the different class.

20. The computer-readable storage medium as recited in claim 15, wherein the program instructions are computer-executable to implement determining that a previously loaded version of a class is not current with a class definition of the class in a class file in response to an invocation of a method of the previously loaded instance of the class.