Developing java server components without restarting the application server

• US 8,543,994 B2
• Filed: 12/07/2007
• Issued: 09/24/2013
• Est. Priority Date: 12/07/2007
• Status: Active Grant

• Current Assignee: SAP SE
• Original Assignee: SAP AG (SAP SE)
• Inventors: de Boer, Martijn, Essenpreis, Mathias
• Primary Examiner(s): Zhen, Wei
• Assistant Examiner(s): BANES, ADAM RICHARD
• Application Number:
  US11/952,920
• Publication Number:
  US 20090150851A1
• Time in Patent Office: 2,118 Days
• Field of Search: None
• US Class Current: 717/166
• CPC Class Codes: G06F 9/44536 Selecting among different versions

Abstract

The subject matter disclosed herein provides methods and apparatus, including computer program products, for developing components, such as Java server components, without restarting the application server hosting those components. In one aspect, there is provided a computer-implemented method. The method may include providing a component comprising an implementation class and an interface class. At the application server, access to the implementation class may be inhibited to enable the application to execute the component without restarting the application. Related apparatus, systems, methods, and articles are also described.

Claims

1. A non-transitory computer-readable medium containing instructions to configure a processor to perform a method, the method comprising:

providing, at an application server, a component comprising an implementation class and an interface class, wherein the interface class is configured to be callable by at least another component and further configured to be changed less often than the implementation class, wherein providing includes providing a first classloader for the implementation class and a second classloader for the interface class, the application server executing the component without restarting; and

inhibiting, at the application server, access to the implementation class to enable the application to execute the component, wherein at least another component may not call the implementation class, the access is being inhibited by inhibiting access to a classloader for the implementation class and the at least another component accesses the implementation class by accessing the interface class through a dedicated classloader, the dedicated classloader loads the implementation class and instantiates the implementation class, wherein the inhibiting includes selecting one of the implementation class and another implementation class, each of which associated with a Java classloader separate from another classloader for the interface class, the selected one being implemented at the application server.

2. The computer-readable medium of claim 1, wherein providing further comprises:

providing the first classloader separate from the second classloader.

3. The computer-readable medium of claim 1, wherein providing further comprises:

providing the implementation class and the interface class at an integrated development environment (IDE) at the application server.

4. The computer-readable medium of claim 1, wherein inhibiting further comprises:

inhibiting access to the implementation class by requiring access to the implementation through the interface class.

5. The computer-readable medium of claim 1, wherein inhibiting further comprises:

accessing the component referenced by other components calling the interface class of the component rather than the implementation class of the component.

6. The computer-readable medium of claim 1, wherein inhibiting further comprises:

accessing the component by calling the interface class; and

implementing, by the interface class, a factory pattern to load the implementation class and instantiate the loaded implementation class.

7. A computer-implemented method comprising:

providing, at an application server, a component comprising an implementation class and an interface class, wherein the interface class is configured to be callable by at least another component and further configured to be changed less often than the implementation class, wherein providing includes providing a first classloader for the implementation class and a second classloader for the interface class, the application server executing the component without restarting; and

inhibiting, at the application server, access to the implementation class to enable the application to execute the component, wherein at least another component may not call the implementation class, the access is being inhibited by inhibiting access to a classloader for the implementation class and the at least another component accesses the implementation class by accessing the interface class through a dedicated classloader, the dedicated classloader loads the implementation class and instantiates the implementation class, wherein the inhibiting includes selecting one of the implementation class and another implementation class, each of which associated with a Java classloader separate from another classloader for the interface class, the selected one being implemented at the application server.

8. The computer-implemented method of claim 7, wherein providing further comprises:

providing the first classloader separate from the second classloader.

9. The computer-implemented method of claim 7, wherein providing further comprises:

providing the implementation class and the interface class at an integrated development environment (IDE) at the application server.

10. The computer-implemented method of claim 7, wherein inhibiting further comprises:

inhibiting access to the implementation class by requiring access to the implementation through the interface class.

11. The computer-implemented method of claim 7, wherein inhibiting further comprises:

accessing the component referenced by other components calling the interface class of the component rather than the implementation class of the component.

12. The computer-implemented method of claim 7, wherein inhibiting further comprises:

accessing the component by calling the interface class; and

implementing, by the interface class, a factory pattern to load the implementation class and instantiate the loaded implementation class.

13. A system comprising:

one or more processors; and

memory including code to configure the one or more processor to perform a method comprising;

providing, at an application server, a component comprising an implementation class and an interface class, wherein the interface class is configured to be callable by at least another component and further configured to be changed less often than the implementation class, wherein providing includes providing a first classloader for the implementation class and a second classloader for the interface class, the application server executing the component without restarting; and

inhibiting, at the application server, access to the implementation class to enable the application to execute the component, wherein at least another component may not call the implementation class, the access is being inhibited by inhibiting access to a classloader for the implementation class and the at least another component accesses the implementation class by accessing the interface class through a dedicated classloader, the dedicated classloader loads the implementation class and instantiates the implementation class, wherein the inhibiting includes selecting one of the implementation class and another implementation class, each of which associated with a Java classloader separate from another classloader for the interface class, the selected one being implemented at the application server.

14. The system of claim 13, wherein inhibiting further comprises:

inhibiting access to the implementation class by requiring access to the implementation through the interface class.

15. The system of claim 13, wherein inhibiting further comprises:

accessing the component referenced by other components calling the interface class of the component rather than the implementation class of the component.

16. The system of claim 13, wherein inhibiting further comprises:

accessing the component by calling the interface class; and

implementing, by the interface class, a factory pattern to load the implementation class and instantiate the loaded implementation class.