Patent Publication Number: US-8539468-B2

Title: System and methods for replacing software application classes using transparent object adapters

Description:
FIELD OF THE INVENTION 
     The present invention is related to the field of software applications, and more particularly, to systems and methods for modifying existing software applications. 
     BACKGROUND OF THE INVENTION 
     Many modern software applications, such a Java® applications, can be characterized as a system comprising multiple subsystems. These different subsystems can be interconnected yet remain separable. Conventionally, when only a particular subsystem of an application in a larger application is to be redesigned such that the remaining portions of the application are unchanged and unaware of the redesign, it is often necessary to provide an object adapter that will emulate replaced objects stemming from the redesign. 
     An object adapter, often referred to as an adapter design or wrapper pattern, adapts one interface for a class into one that can function with other classes. Specifically, an adapter allows classes that would otherwise comprise incompatible interfaces to function cooperatively. The adapter typically accomplishes this by wrapping its own interface around that of an existing class. 
     When an old object and a new one have different names or are in different software packages, each comprising a group of related classes of an application program, it is typically necessary to provide a solution based on a wrapper or delegation pattern implemented as an object adapter. With a wrapper or delegation pattern, an object outwardly expresses certain behaviour, but in reality delegates responsibility for implementing that behavior to an associated object. 
     This is often not an optimal solution, however, because it requires that the adapter instance contain the instance of the class that it wraps. This conventional technique requires that an adapter and the instance wrapped by the adapter be created from both the new subsystem—which ideally should not be aware of the existence of the adapter instances—and those portions of the original application that should otherwise remain unaltered and unaware of the change. With the conventional technique, moreover, there arises a performance penalty if an adapter is created for every instance of a given class where only some of the instances need be referenced from outside the redesigned subsystem. 
     SUMMARY OF THE INVENTION 
     The present invention is directed to systems, computer products, and related methods for creating transparent object adapters for use when, within an application such as a Java-based® application, one subsystem of the application is replaced with another. An object of the invention is to avoid the necessity of having to create an adapter and a corresponding wrapped instance when redesign of an application replaces one subsystem of a system comprising a program or application with another subsystem. Another object of the invention is to avoid the penalty that would otherwise be incurred were an adapter created for every instance of a given class of the subsystem even though only some of the instances need to be referenced from outside the subsystem that replaces another. The systems and methods, moreover, can allow simultaneous development of part of an application that is outside of the changed subsystem without waiting for changes to be completed and without altering code outside of the subsystem. 
     One embodiment of the invention is computer-based system for creating transparent object adapters for replaced classes in an application program. The system can include one or more processors for executing computer-readable code and an object adapter generating module that is configured to execute on the one or more one processors. More particularly, the object adapter can be configured to determine whether an original class of an original subsystem of the application system is referenced by at least one other of the multiple subsystems in response to the subsystem being replaced by a new subsystem. The object adapter can generate a pair of corresponding classes for the original class if the original class is referenced by at least one other of the multiple subsystems. One of the generated classes defines an object adapter class having a same name and software package as the original class. The other defines a new classes. 
     The object adapter generating module can configure the object adapter class to export all methods referenced by at least one other of the multiple subsystems and to perform, according to predetermined adapter logic, at least one among transforming data and handling references to adapter objects passed as parameters or returned values. The object adapter generating module also can configure the object adapter class and the new class to maintain references to one another. 
     Another embodiment of the invention is a computer-implemented method for creating transparent object adapters for replaced classes in an application comprising multiple subsystems. The method can include responding to substitution of a new subsystem for an original one of the subsystems by determining whether an original class of the original subsystem is referenced by at least one other of the multiple subsystems. According to the method, if the original class is referenced by at least one of the other multiple subsystems, a pair of corresponding classes for the original class can be generated. One of the generated classes can define an object adapter class having a same name and package as the original class, and the other generated class can define a new class. The object adapter class, more particularly, can be configured to export methods referenced by at least one other of the multiple subsystems and to perform at least one among transforming data and handling references to adapter objects passed as parameters or returned values. The object adapter class and the new class can both be configured to maintain references to one another. 
     Yet another embodiment is a computer product, such an optical media disk, having computer code embedded therein. The computer code can be configured to cause a computer, when loaded on the computer, to perform the procedures and functions of the above-described method. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       There are shown in the drawings, embodiments which are presently preferred. It is expressly noted, however, that the invention is not limited to the precise arrangements and instrumentalities shown. 
         FIG. 1  is a schematic view of a system for creating transparent object adapters, according to one embodiment of the invention, according to one embodiment of the invention. 
         FIG. 2  is a schematic view of certain operative features of the system illustrated in  FIG. 1 . 
         FIG. 3  is a flowchart of exemplary steps in a method for creating transparent object adapters, according to another embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1  is a schematic view of a computer-based system  100  for creating transparent object adapters for replaced classes in an application program comprising multiple application subsystems, according to one embodiment of the invention. The system  100  illustratively comprises one or more logic-based processors  102  comprising registers (not explicitly shown), logic gates (also not shown explicitly shown), and other logic-based circuitry for processing executable code. Optionally, the system  100  can include electronic memory  104  for storing electronic data and executable code  108   a - c . The electronic memory  104  is illustratively communicatively linked to the one or more processors  102  through a bus  106 . 
     The system  100  further includes an object adapter generating module  110 . The object adapter generating module  110  can be implemented in processor-executable code configured to run on the one or more processors  102  for performing the procedures described herein. Alternatively, however, the object adapter generating module  110  can be implemented in dedicated hardwired circuitry for performing the same procedures. In still another embodiment, the object adapter generating module can be implemented in a combination of executable code and hardwired circuitry. 
     Referring additionally now to  FIG. 2 , certain operative aspects  200  of the object adapter generating module  110  are schematically illustrated with respect to an application program or system  202 . The application system  202  illustratively comprises multiple modules or subsystems  204 ,  206 ,  208 . The application system  202  can comprise, for example, a Java® application. The subsystem  204 ,  206 ,  208  of the application system  202  are separable, but interconnected with one another. The operative procedures of the object adapter generating module  110  are initiated when one of the original subsystems  206  of the application system  202  is to be replaced by a new subsystem  210 , which requires a different class structure than the original subsystem  206  for which the alternative subsystem is substituted. It can be assumed that for every instance of the original subsystem  206  there exists only one object instance in the new subsystem  210 . According to this embodiment, the code comprising the other subsystems  204 ,  208  of the application system  202  remain unaware of the substitution of the new subsystem  210  for the original subsystem  206 . 
     Operatively, the object adapter generating module  110  initially determines whether any original class of the original subsystem  206  of the application system  202  is referenced by at least one other of the multiple subsystems  204 ,  208  in response to the subsystem being replaced by the new subsystem  210 . If an original class  212  is referenced by at least one other of the multiple subsystems  204 ,  208 , then the object adapter generating module  110  generates a pair of corresponding classes  214 ,  216  for the original class  212 . One of the generated classes defines an object adapter class  214  having the same name and package as the original class  212 . The other of the new classes defines a new class  216   
     More particularly, the object adapter generating module  110  configures the object adapter class  214  to export all methods referenced by at least one other of the multiple subsystems  204 ,  208 . The object adapter generating module  110  also configures the object adapter class  214  to transform data and/or handle references to adapter objects passed as parameters or as returned values. The object adapter generating module  110  further configures both the object adapter class  214  and the new class  216  to maintain references to one another. 
     Accordingly, the object adapter generating module  110  is able to generate a corresponding pair of new classes—namely, an object adapter class and a new class—for every original class that is referred to from outside the replaced subsystem  206 . The methods of the object adapter class  214  make calls into the new subsystem  210 , providing any necessary logic needed to transform data or handle references to adapter objects passed as parameters or returned as values. The new class  216  can have any name and any package. The new class  216  is designed solely from the point of view of the new subsystem  210  that is substituted for the original subsystem  206  and does not need, indeed preferably does not implement, any adapter logic. 
     The object adapter class  214  and the new class  216  maintain references to each other such that when there are no external references to any of these classes, a virtual or software-implemented garbage collector can dispose of both instances. When an instance of one of the classes, the object adapter class  214 , an instance of the new class  216  is created and cross references are established. Creating the object adapter class always causes the new class  216  to be created. The object adapter class  214 , however, is created only when a reference to the object adapter class needs to be passed to one other of the multiple subsystems  204 ,  208 , which are external to subsystem  206 . This configuration allows for a smooth and gradual transition to the use of new classes by the remaining portions of the application system  202 . 
     According to a particular embodiment, the object adapter generating module  110  can be configured to generate the new class  216  (for exposition, here designated as NewClass) to have a private reference attribute to an instance of the original class  212  (for exposition, here designated as OldClass). The reference can be initialized with a null. An adapter object thus need not, and preferably is not, instantiated until it is needed. The NewClass can be configured by the object adapter generating module  110 , according to still another embodiment, to define a public method (for exposition, designated as getAdapterInstance( )), which can be used exclusively when the adapter instance needs to be referenced. The method, getAdapterInstance( ), can check whether an adapter instance has been initialized. If the adapter instance has not been initialized, the method creates an instance of OldClass, initializes it with a reference to the corresponding NewClass instance, and assigns it to the reference attribute in the NewClass instance. Moreover, the method, getAdapterInstance ( ), is preferably synchronized for thread safety, as will be readily understood by one of ordinary skill. 
     According to yet another embodiment in the specific context of a Java-based® application, OldClass can be configured to have a private attribute based on a defined class, WeakReference (defined in Java 1.2), the private attribute pointing to the instance of NewClass. The private attribute can be initialized from all constructors of OldClass with a weak reference to the NewClass instance. Two types of constructors can be implemented in OldClass. The first type of constructor takes as a parameter a reference to an instance of NewClass and initializes the WeakReference object with that reference. The constructor is used in the exemplary method, getAdapterInstance ( ), implemented by NewClass. 
     The second type of constructor for OldClass is a constructor that is called from parts of the application system  202  outside the new subsystem  210 . Such a constructor may not be necessary if instances are created only from the new subsystem  210 . The constructor initializes the WeakReference attribute with a new instance of NewClass. With this second type of constructor, NewClass implements another constructor that takes as a parameter a reference to the OldClass instance and assigns it to its reference attribute. 
     Depending on particular design requirements, OldClass and all its methods can be marked as deprecated; in this event, instructions can be provided to developers describing the manner in which to make the transition to the usage of new classes that replace original classes. When the transition is completed for any of the old classes, OldClass, the reference to in NewClass and the method NewClass.getAdapterInstance ( ) can be removed. 
     The following code is an illustrative implementation of the techniques and procedures thus far described, the implementation showing only the code that is relevant to adapter functionality: 
     
       
         
           
               
             
               
                   
               
             
            
               
                   package company.product.subproduct.oldpackage; 
               
               
                   import java.lang.ref.WeakReference; 
               
               
                   public class OldClass 
               
               
                   { 
               
               
                     private WeakReference&lt;NewClass&gt; masterInstance = null; 
               
               
                     public OldClass(NewClass masterInstance) 
               
               
                     { 
               
               
                       this.masterInstance = new WeakReference&lt;NewClass&gt; 
               
               
                       (masterInstance); 
               
               
                     } 
               
               
                   public OldClass( ) 
               
               
                   { 
               
               
                     masterInstance = new WeakReference&lt;NewClass&gt; 
               
               
                     (new NewClass(this)); 
               
               
                   } 
               
               
                   public NewClass getMasterInstance( ) 
               
               
                   { 
               
               
                   return masterInstance.get( ); 
               
               
                   } 
               
               
                   // A simple example of usage 
               
               
                   public void doSomething( ) 
               
               
                   { 
               
               
                     // delegate 
               
               
                     return getMasterInstance( ).doSomething( ); 
               
               
                   } 
               
               
                   // A more complicated example that involves two more new classes 
               
               
                 with adapters: 
               
               
                 // an instance of the adapter YetAnotherOldClass is passed by the caller as 
               
               
                 // a parameter and an an instance of an adapter AnotherOldClass is 
               
               
                 returned to the outside caller 
               
               
                   public AnotherOldClass doSomethingElse(YetAnotherOldClass 
               
               
                   parameter) 
               
               
                   { 
               
               
                     // delegate 
               
               
                   return 
               
               
                 (getMasterInstance( ).doSomethingElse(parameter.getMasterInstance( )).- 
               
               
                 getAdapter Instance( ); 
               
               
                   } 
               
               
                 } 
               
               
                 package company.product.subproduct.newpackage; 
               
               
                 import company.product.subproduct.oldpackage.OldClass; 
               
               
                 public class NewClass 
               
               
                 { 
               
               
                   private OldClass adapterInstance = null; 
               
               
                   public NewClass( ) 
               
               
                   { 
               
               
                   } 
               
               
                   public NewClass(OldClass adapterInstance) 
               
               
                   { 
               
               
                     this.adapterInstance = adapterInstance; 
               
               
                   } 
               
               
                   public synchronized OldClass getAdapterInstance ( ) 
               
               
                   { 
               
               
                     if (adapterInstance == null) 
               
               
                     { 
               
               
                       adapterInstance = new OldClass(this); 
               
               
                     } 
               
               
                     return adapterInstance; 
               
               
                   } 
               
               
                 ... 
               
               
                 } 
               
               
                   
               
            
           
         
       
     
     It should be noted that with the support of the Java environment, for example, the lifecycle of the instances of adapters and new class can be managed by these classes themselves. 
     Moreover, the need to create the adapter as an upfront system can be avoided; the adapter is created only as needed (i.e., only when it is referenced by an external subsystem). The instances of the new class are created as needed, and adapters are created only when these instances need to be referenced by an external subsystem. 
     In one aspect, external subsystems can—though they need not in order to keep the whole system workable—be changed gradually to reference the new classes. All external subsystems are eventually modified to reference the new classes directly. Subsequently, the adapter can be disposed of. Even if it is preserved, however, there a very minor penalty (one attribute initialized with null) can be applied for maintaining it in place. There is no requirement that external subsystems go through the adapters. Quite the opposite: as the external subsystems go through their own cycle of development and maintenance, they can, and typically should be, modified to reference the new classes directly. This is one of the benefits of the simultaneous—or decoupled—development of the new subsystem and the rest of the subsystems. 
       FIG. 3  is a flowchart of exemplary steps in a method  300  for creating transparent object adapters for replaced classes in an application comprising multiple subsystems. The method  300  illustratively includes, after the start at step  302 , determining at step  304  whether an original class of the original subsystem is referenced by at least one other of the multiple subsystems in response to substituting a new subsystem for an original one of the subsystems. 
     If the original class is referenced by at least one of the other multiple subsystems, however, then a pair of corresponding classes are generated based upon the original class. Specifically, at step  306  a class defining an object adapter class is generated, the object adapter class having the same name and package as the original class. The other of the generated classes, generated at step  308 , defines a new class. 
     It is to be noted, however, that the order in which the pair of classes are generated according to the method  300  is only illustrative. In other embodiments, the order in which the object adapter class and new class are generated can be reversed. In still other embodiments, both pair of classes can be generated simultaneously or nearly so. 
     If the original subsystem is not referenced by at least one of the other subsystems, then the method  300  proceeds to step  310  where optionally the method  300  can include determining whether the original subsystem includes one or more additional classes. If one or more additional classes remain, then the method  300  optionally can return to step  304  and the procedure repeated. The method  300  illustratively concludes at step  312 . 
     There can be several different process flows. In one process flow, an instance of a new class is created and used by either the new subsystem or an external subsystem that has become aware of the existence of the new class. No adapter instance is ever created. 
     In another process flow, an instance of the adapter is created from an external subsystem, which the system assumes still performs with the old class; the system need not be aware that it does not work with the old class. An instance of the new class is immediately created and linked to the adapter. The instance of the new class can itself create other instances within the new subsystem, but adapters for these instances will be created only as needed, as discussed in the follow paragraph. 
     In still another process flow, an external subsystem makes an adapter call into the new subsystem through a static method or through an adapter method, and this call needs to return a reference to an old object (or references to old objects). The adapter that returns the call to the external subsystem obtains these references by calling the above-described method for obtaining the references, exemplified by method getAdapterInstance( ), on the instance or instances of the new class or classes. Two possible courses of the process can occur at this point: (1) there is already an instance of the adapter for the new class that has been previously created—then it is returned, or (2) the adapter instance did not exist yet, but then it is created and returned. 
     When there are no more references to the adapter (from external systems only) and to the new class (from anywhere), both the adapter and the new class can be collected for disposing. In particular, in a Java environment, when there are no references to the adapter and new class, both can be garbage collected “automatically” without the active participation of any component of the program. 
     As generated according to the method  300 , the object adapter class is configured to export methods referenced by at least one other of the multiple subsystems and to perform at least one among transforming data and handling references to adapter objects passed as parameters or returned values. Moreover, the object adapter class and the new class are configured according to the method  300  so as to maintain references to one another. 
     The method  300 , according to one embodiment, can further comprise configuring the new class so that the new class is devoid of adapter logic. According to still another embodiment, the method  300  further comprises disposing of instances of the object adapter class and the new class when there are no external references to either class by at least one of the other subsystems. The disposing, according to a particular embodiment, can be performed by an application-implemented garbage collector. 
     According to yet another embodiment, the method  300  can further comprise configuring the new class to have a private reference attribute to an instance of the original class. Additionally, according to one embodiment, the private reference attribute can be initialized with a null such that an adapter object is not instantiated until required by one of the other subsystems. 
     According to still another embodiment, the method can further comprise configuring the new class to have a public method that references an adapter instance. The public method, according to a particular embodiment, can be configured to determine whether the adapter instance is initialized and, if the adapter is not initialized, to create an instance of the original class, initialize the instance of the original class with a reference to a new class instance, and assign to the instance of the original class a reference attribute of the new class instance. 
     According to another embodiment of the method  300 , the original class can contain a private attribute that points to an instance of the new class. The private attribute be initialized from each constructor of the original class with a weak reference to the instance of the new class. 
     The invention, as also already noted, can be embedded in a computer program product, which comprises all the features enabling the implementation of the methods described herein, and which when loaded in a computer system is able to carry out these methods. Computer program in the present context means any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after either or both of the following: a) conversion to another language, code or notation; b) reproduction in a different material form. 
     The foregoing description of preferred embodiments of the invention have been presented for the purposes of illustration. The description is not intended to limit the invention to the precise forms disclosed. Indeed, modifications and variations will be readily apparent from the foregoing description. Accordingly, it is intended that the scope of the invention not be limited by the detailed description provided herein.