JP2004246789A - Program function expansion system, program function expansion method, program function expansion program and record medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To avoid reduction in productivity caused by a change of an API, and to realize substantial function expansion without changing the API. <P>SOLUTION: When calling a method mounted with an old API by use of a reflection function of a program language processing execution system, control is transferred to a meta-level process (a processing system level, a level allowing execution of behavior of a meta-object such as a class or a method), execution of an old method is snatched in a meta-level, and a new method corresponding to an old method object is retrieved and is executed instead of the old method inside the meta-level process. Thereby, if a client only executes a code calling the old API as it is without changing the code, a process corresponding to a new API is substitutionally executed in the meta-level. <P>COPYRIGHT: (C)2004,JPO&NCIPI

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a mechanism for coordinating and managing programs that cooperate via an API, and more particularly to a program function expansion system, a function expansion method, a program function expansion program, and a recording medium for expanding functions while maintaining compatibility.
[0002]
[Prior art]
Methods for improving productivity and reducing development time in service development on the Internet include technical fields such as service cooperation and Web services. In addition, EAI (Enterprise Application Integration) technology and the like are also methods of constructing services by linking existing systems (for example, see Non-Patent Documents 1 and 2).
[0003]
A plurality of services cooperate on the cooperative service mechanism. In such a situation, an interface between a program that provides a function and a program that uses the function is an API (Application Programming Interface).
[0004]
The API providing program (server: Server) implements the function and publishes it as an API, while the API using program (client: Client) implements the function based on the API while implementing its own application logic. To invoke, the API can be viewed as a protocol that both parties must adhere to.
[0005]
Conventionally, in CORBA technology and EJB (Enterprise JAVA (registered trademark) Beans) technology in J2EE (Java (registered trademark) 2 Enterprise Edition), an interface is indirectly referred to by a name using a function that provides a naming and directory function. (For example, see Non-Patent Documents 3 and 4). However, the API use side program (client) needs to be aware of the new interface in the part where the new function is called. That is, it was necessary to modify the program in the calling part on the client side. In addition, functions can be replaced in units of interfaces, but functions are not replaced in units of object methods.
[0006]
[Non-patent document 1]
Ryuichi Hino and one other, "Proposal of AP Development Method by Platform Cooperation", IEICE, March 22, 2002, IEICE Technical Report KBSE 2001-72, pp. 57-64
[Non-patent document 2]
Keitaro Horiyo and one other, "Consideration of I / F between systems and the effects of expansion", IEICE, December 12, 2002, IEICE technical report vo1.102, N0. 503 pp. 7-12
[Non-Patent Document 3]
, "JAVA (registered trademark) & CORBA C / S Programming", published by Nikkei BP, January 1999, pp. 11, 62, 3353, 359
[Non-patent document 4]
Michael Gardley et al., "J2EE & BEA WebLogic Server Developer's Guide", Pearson Edescation, November 2001, pp. 26,173-208,236
[0007]
[Problems to be solved by the invention]
By the way, in the program development process, specification changes and function expansions generally occur at various levels, large and small. Similarly, in a development environment that links existing systems, API changes may be unavoidable due to reasons such as individual components that are constituent elements extending their own functions, and requests to compensate for the lack of functions as a whole. Not a few exist.
[0008]
For fixes that do not change the interface, such as simple bug fixes, the scope of influence does not extend outside the interface, so it is possible to reduce the cost of fixing and testing, but as described above, the API is Since this is a convention between programs that cooperate via it, changing the API affects all programs that comply with it. This is essentially an unavoidable problem.
[0009]
Therefore, with the change of the API, it becomes necessary to implement and test additional functions in the server that provides the API and all clients that use the API, and as a result, the development cost increases.
[0010]
Also, adding a new function to the quality in the steady state, which has been subjected to the operation test with the API before the change, may be a factor of lowering the quality, and increases the risk in quality.
[0011]
Furthermore, when the interface is changed by the API extension, if a function addition and a test cost for assuring compatibility are also included, there is a problem that the cost of the entire development is further increased.
[0012]
The present invention has been made in view of the above-described circumstances, and has a program function extension capable of avoiding a decrease in productivity caused by changing an API and realizing a substantial function extension without changing the API. It is an object to provide a system, a program function extension method, a program function extension program, and a recording medium.
[0013]
[Means for Solving the Problems]
In order to solve the above-mentioned problems, the invention according to claim 1 manages cooperation of a plurality of programs that cooperate via an API, and maintains API compatibility when changing an API that is a protocol between programs. A program function extension system for extending an old API function to a new API function while executing a plurality of programs that cooperate through the old API function while corresponding to a method object that implements the old API function Processing means for dynamically registering / changing / deleting an old API function; and a meta-level processing for controlling activation / execution of the old API function using the method object of the old API function as a key by using the method object of the old API function. From the alternative processing object acquisition means for searching and acquiring the API, and additional information and API accompanying the API extension An alternative processing object executing means for executing the alternative processing object acquired by the alternative processing object acquiring means instead of executing the old API function while maintaining consistency with the return information; and an alternative processing of the alternative processing object executing means In executing the object, a fusion process executing means for performing a process in which the alternative function and the old API function are fused is provided.
[0014]
According to a second aspect of the present invention, in the program function extension system according to the first aspect, the alternative processing management means is realized by a hash table that stores an old API processing object and a new API processing object in association with each other as keys. It is characterized by being performed.
[0015]
According to a third aspect of the present invention, in the program function extension system according to the second aspect, as a result of searching for a new API processing object using the old API processing object as a key, the value corresponding to the key is changed. If it is empty, the old API processing is executed as it is and the result is returned. If the value corresponding to the key is not empty and a new API processing object is assigned, the new API processing object is taken out and the alternative processing is executed. The message is issued to the user.
[0016]
According to a fourth aspect of the present invention, in the program function extension system according to the second aspect, the alternative processing management means is configured based on a Singleton design pattern.
[0017]
Further, in order to solve the above-mentioned problem, the invention according to claim 5 manages cooperation of a plurality of programs that cooperate via an API, and improves API compatibility when changing an API which is a protocol between programs. A program function extension method for extending an old API function to a new API function while maintaining a plurality of programs operating cooperatively via the old API function, the method corresponding to a method object that implements the old API function during execution. In meta-level processing for controlling the activation and execution of the old API function by dynamically registering / changing / deleting the processing object, search / acquire the alternative processing object using the method object of the old API function as a key, and add with the API extension Instead of executing the old API function while maintaining the consistency between the information and the return information from the API, the acquired Run the replacement process object, in the alternative process object execution, and executes the processes in fusion with the alternative function and the old API function.
[0018]
In order to solve the above-mentioned problem, the invention according to claim 6 manages cooperation of a plurality of programs that cooperate via an API, and improves API compatibility when changing an API that is a protocol between programs. A program function extension method for extending an old API function to a new API function while maintaining the same, using a reflection function provided in a program language processing execution system to control meta-level processing when a method for implementing the old API function is called. The execution of the old method is intercepted at the meta level, a new method corresponding to the old method object is searched, and the new method is executed instead of the old method within the meta level processing.
[0019]
According to a seventh aspect of the present invention, in the method of extending a program function according to the sixth aspect, an old API processing object for realizing a function corresponding to the old API and a new API processing object for realizing a function corresponding to the new API are provided. Are managed in association with each other.
[0020]
In order to solve the above-mentioned problem, in the invention according to claim 8, during execution of a plurality of programs that cooperate via the old API function, an alternative process corresponding to a method object that implements the old API function is executed. Dynamically registering / changing / deleting an object; searching / acquiring an alternative processing object using a method object of the old API function as a key in meta-level processing for controlling activation / execution of the old API function; Executing the acquired alternative processing object in place of executing the old API function while maintaining the consistency between the additional information accompanying the API and the return information from the API. Executing a process integrated with the old API function. To.
[0021]
In order to solve the above-mentioned problem, according to the ninth aspect of the present invention, during execution of a plurality of programs that cooperate via the old API function, an alternative process corresponding to a method object that implements the old API function is executed. Dynamically registering / changing / deleting an object; searching / acquiring an alternative processing object using a method object of the old API function as a key in meta-level processing for controlling activation / execution of the old API function; Executing the acquired alternative processing object in place of executing the old API function while maintaining the consistency between the additional information accompanying the API and the return information from the API. And a step of executing processing integrated with the old API function. And characterized by recording a function expansion program.
[0022]
According to the present invention, when a method for implementing the old API is called, a meta-level process (a level at which the behavior of a meta-object such as a class or a method is executed) is controlled by using a reflection function provided in the programming language processing execution system. Is transferred, the execution of the old method is intercepted at the meta level, a new method corresponding to the old method object is searched, and the old method is executed instead of the old method within the meta level processing. Therefore, the API user simply executes the code that calls the old API without any change, and the processing corresponding to the new API is executed at the meta level as an alternative. As a result, the function expansion can be performed while maintaining the compatibility of the API. Will be possible.
[0023]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings.
[0024]
FIG. 1 is a conceptual diagram showing an operation and an effect of a program function expanding method according to an embodiment of the present invention. Note that the program function expansion method according to the present embodiment uses a language processing system having a reflection function such as a JAVA (registered trademark) language or a Python language. The figure shows a case in which an old API function is extended to a new API function, and the new API requires one additional parameter. In the server program 10, an object that implements and discloses an API is defined as a receiver. In the client program 20, an object that calls the API of the server is a sender. The server program 10 and the client program 20 may be included in the same language processing execution system (equivalent to a VM of JAVA (registered trademark)), or may be provided via a distributed object mechanism such as JAVA (registered trademark) RMI. They may be linked.
[0025]
The old API function 40 is a function of giving two objects (x, y) as inputs and outputting “v” as a result, and is assumed to be realized by the method method of the receiver object. On the other hand, the new API function 50 is a function that gives three objects (x, y, z) as inputs and outputs “φ (V)” as a result, but is not realized in advance by the method method of the receiver object. You may.
[0026]
The protocol 30 in which the client program 20 calls the old API to the server program 10 issues a method request “v = receiver.method (x, y)” to the receiver object in the execution thread of the sender object.
[0027]
Here, the features of the present invention include the implementation of the receiver object in the server program 10, the implementation of the sender object in the client program 20, and the method request calling protocol 30: v = receiver. That is, the old API function 40 is changed to the new API function 50 without changing any of the method (x, y).
[0028]
The implementation of the new API function 50 is defined as an object that implements the Executable interface. The Executable interface seeks a method "public Object Executeable # execute (Object [] args)" as an essential method.
[0029]
Apply the Command design pattern and define an object that implements the Executable interface, or define a new class of "New Executable () {public Object execute (Object [] args)} / * Logic of the new API function * / {" as an anonymous class. Implemented as an object.
[0030]
The implementation of the new API function may be defined in any of a client program, a server program, and a third-party program.
[0031]
A new API function: a function of giving three objects (x, y, z) as inputs to the body of the execute () method and outputting “φ (V)” as a result is defined. At this time, as information for realizing the new API function, a receiver object, a sender object, a receiver # method () method object, real parameters x and y, an additional real parameter z, and a method getZ () for acquiring the z are provided. Is required, a process for obtaining these is defined in the execute () method.
[0032]
For example, a parameter for execute (): Object [] args, storing and passing the entity, passing as a parameter at the time of generation of an object implementing the Executable interface, and acquiring at execution time by a method callback to the sender and receiver objects Necessary information can be obtained by an arbitrary method by means such as communication with an external file or a network, and the definition of execute () is not particularly limited.
[0033]
If it is desired to execute various types of different processes according to the situation, one class implementing Executable is provided, and within the class, various processes are defined as one internal class for each different process. Define by bundling in one class. As a result, addition and deletion of processing can be realized by adding and deleting internal classes. Therefore, a series of processing sets can be managed in an organized manner without defining and creating many small classes separately.
[0034]
By applying the Command design pattern, objects implementing Executeable are uniformly activated from the outside by an execute () method call from the outside to perform desired processing.
[0035]
Next, FIG. 2 is a conceptual diagram showing means for realizing a program function extension according to an embodiment of the present invention, together with a specific example. In FIG. 2, the substitution process management unit 100 replaces the Executable implementation object (new API processing object) 200 that realizes the new API function with the Method object (old API processing object) R # method (x , Y). The substitution process management unit 100 has a hash table or is realized by inheriting a hash table function.
[0036]
The Method object of the receiver object that implements the old API function is obtained by “receiver.getClass (). GetDeclaredMethod (“ method ”, newClass [] {x.class, y.class})”, and this is obtained from the hash table. An Executable implementation object that implements the new API function is added to the management as a value corresponding to the key.
[0037]
A Method object in which a key / value pair is registered in the hash table means that the alternative processing is defined, and an object in which no key or value is registered has no alternative processing. Means to execute.
[0038]
Therefore, another Executable implementation is provided in which an Executable implementation object serving as a value is assigned (register) to a method serving as a key, and an alternative process is added and deleted by removing (remove) the original process. By allocating (updating) the object, three types of operations, that is, changing the substitution process, can be performed.
[0039]
The Method activation handler unit 500 is a mechanism that is hooked when an old API method is called for an object that provides an old API, and can acquire a proxy object, the method object, and actual parameters at the time of the call as objects.
[0040]
java. lang. renet. In the method that implements and defines “public Object invoke (Object proxy, Methodm, Object [] args)” of the InvationHandler interface, calls the function of the proxy processing management unit 100 and searches for an alternative processing object corresponding to the method object. ·Execute.
[0041]
The details will be described below. In this embodiment, when the API is extended, both the API providing side (server) and the API using side (client) extend the API and the function without modifying the program code.
[0042]
Specifically, using the reflection function provided in the programming language processing execution system, when calling a method that implements the old API, the processing at the meta level (processing system level, level at which the behavior of the meta object such as class or method is executed) is performed. The control is transferred, the execution of the old method is intercepted at the meta level, a new method corresponding to the old method object is searched, and the old method is executed instead of the old method within the meta level processing.
[0043]
As a result, the client simply executes the code that calls the old API without changing it, and instead executes the processing corresponding to the new API at the meta level. As a result, the function can be extended while maintaining the compatibility of the API. become.
[0044]
The old API processing object can be obtained by a Method object (in the case of JAVA (registered trademark) API, an instance of the java.lang.reflect.Method class), and the new API processing object can be realized by an alternative Method object or Command design pattern. Give in the object.
[0045]
An object that embodies the processing by the command design pattern is an object accompanied by one or more indispensable methods (for example, Executable # execute (Object [] args) or the like) specified by Interface, and 0 or more objects required for the processing. An object process is defined by bundling and instantiating object references and invoking a method specified by interface.
[0046]
The alternative processing management unit 100 is realized by a hash table (in the case of JAVA (registered trademark) API, an instance of the java.util.Hashtable class), and stores an old API processing object as a key and a new API processing object as a corresponding value.
[0047]
As a result of searching for a new API processing object using the old API processing object as a key for the alternative processing management unit 100, if the value corresponding to the key is empty (null), the old API processing is executed as it is and the result is returned. . On the other hand, if the value corresponding to the key is not empty and a new API processing object is assigned, the new API processing object is extracted and an execute () message is issued to execute the substitute processing.
[0048]
At this time, if it is necessary to use the processing result of the old API, the old API processing object can be passed to the new API processing object to combine the processing. For example, the debug log is output immediately after the method call of the old API and immediately before the return, or the process that measures the time required for the processing of the method body and uses it for performance measurement is added to the old API method in the substitute processing object. It is only necessary to integrate the functions, and the method can be realized in a unified manner.
[0049]
The alternative process management unit 100 designs and implements based on the Singleton design pattern. This guarantees that there is only one in the same processing system (in the case of Java (registered trademark), JAVA (registered trademark) VM), and that a specific object refers to the alternative processing management class. It can be appropriately referenced from any method (by the alternative process management class #getInstance ()) without being tightly coupled (such as by holding it as an instance variable).
[0050]
Therefore, when the old API process is activated, it is possible to refer to the alternative process management class even in the method of the meta-level process for executing the method activation, and when the old API method is executed, the corresponding new API process object is searched. I can do it.
[0051]
A new API processing object is prepared by a third party other than the server developer, the client developer, or both, and the correspondence with the old API can be dynamically linked. In other words, during the execution of a plurality of programs that cooperate via the old API, it is possible to add, change, or delete an alternative process corresponding to the old API. Behavior can be changed dynamically.
[0052]
In order to access the meta-level processing of the method invocation processing of the old API, the context at the time of execution of the old API method, that is, all {instance, method, and actual parameters} to be executed are acquired, and the processing defined by the user at the meta-level Connect dynamically. For example, if the language used is Java (registered trademark), a dynamic proxy of the Java (registered trademark) reflection function is used. That is, java. lang. Proxy class and API call handler java. lang. The above operation can be performed by using InvocationHandler # invoke ().
[0053]
In the process of dynamically linking the above processes, the alternative process management class is accessed, and the alternative process corresponding to the old API method object is executed. As a result, the API function can be substantially extended without changing the API calling interface, and the program of both the server and the client is not modified. Therefore, it is easy to extend the function while maintaining compatibility. Is achieved. Also, since the test program does not need to be changed, the test operation is simplified.
[0054]
FIG. 3 is a block diagram showing a functional configuration for implementing a program function extension according to the embodiment of the present invention. The substitution process management unit 100 includes a substitution process search unit 110, a substitution process registration unit 111, a substitution process update unit 112, a substitution process deletion unit 113, a substitution process search / execution unit 114, and a substitution process synthesis / execution unit 115. . The replacement process search unit 110 has a function of searching for a replacement process using the method of the old API as a key, and can be realized using the hash table search mechanism as described above. The substitute process registration unit 111 has a function of registering a substitute process using the method of the old API as a key, and can be realized by using the function of adding to the hash table as described above.
[0055]
The replacement process update unit 112 has a function of updating the replacement process using the method of the old API as a key, and can be realized by using the function of adding to the hash table as described above. The substitution process deletion unit 113 deletes the method of the old API from the substitution process of the key and returns to the original function, and can be realized by using the function of deleting the value from the hash table as described above. The substitution process search / execution unit 114 has a function of searching for a substitution process using the method of the old API as a key and automatically executing the substitution process. The substitution process retrieval function and an execute () message to the Executable object Can be realized. The substitution process synthesis / execution unit 115 has a function of automatically executing the old API method and executing the substitution process at the same time as searching for the substitution process using the method of the old API as a key. This can be realized by invoking the old API method and issuing an execute () message to the Executable object.
[0056]
The substitution process object definition unit 201 has a function of defining an Executable implementation object to be registered in the substitution process management unit 100. Usually, it can be realized by editing and compiling the source code of JAVA (registered trademark), and arranging the generated class file at a position visible to JAVA (registered trademark) VM from outside.
[0057]
The Method activation handler unit 501 has a function of inquiring of the alternative process management unit 100 whether or not an alternative process is registered, and requesting execution of the alternative process. Alternative processing such as necessity of execution of the old API method, addition of additional processing (log output, output of profile information, output of performance information, etc.) before and after alternative processing, registration / change / deletion of alternative processing itself It is possible that there are a plurality of types of Method startup handler units depending on the behavior at the time of execution of the. The method can be realized by calling the alternative process management unit 100 after hooking the activation of the method using the dynamic proxy class of the JAVA (registered trademark) reflection function.
[0058]
The client program unit 301 is a part that calls the old API and controls execution of higher-order business logic using the result. There may be multiple client programs depending on the type of business logic. The server program unit 401 has a function of realizing the old API, publishes the old API, and executes and controls a program that executes a request to the API and returns a result. There may be a plurality of server programs depending on the type of API and the provided program.
[0059]
The language processing execution system 1000 is a language processing execution system that controls execution of the alternative processing management unit 100, the alternative processing object definition unit 201, the client program unit 301, the server program unit 401, and the method start handler unit 501. In the case of JAVA (registered trademark) language, it corresponds to JAVA (registered trademark) VM. It is not always necessary to be the only entity, and a distributed JAVA (registered trademark) VM configuration may be used as long as the uniqueness of the object is guaranteed by using the JAVA (registered trademark) RMI technology.
[0060]
Next, a specific example for realizing the program function extension according to the embodiment of the present invention will be described. Here, FIGS. 4 to 8 are conceptual diagrams showing specific program examples. FIG. 4 shows an implementation example of a receiver object in a server program. The Receiver interface exposes two APIs, an old API (String, String) and a new API (String, String, String). The former represents the old API, and the latter represents the new API. The latter need not necessarily be defined in advance in the server program. This is prepared in advance for the Receiver interface in order to simplify the explanation. The ReceiverImpl class is a concrete class that implements the Receiver interface. Both oldAPI () and newAPI () implement a function of combining and returning a character string given by a parameter.
[0061]
By applying the present invention, the client-side program using the old API can execute the API without changing the logic for calling the old API (String, String) with two character strings (that is, while maintaining compatibility). After the extension, a new API (String, String, String), which is an implementation of the extended API function, is automatically called.
[0062]
Next, FIG. 5 shows an implementation example of a Sender object in the client program. The Sender inkface discloses two APIs, a callOld API (String, String) and a callNew API (String, String, String). The former represents the old API, and the latter represents the new API. The latter need not necessarily be defined in the client program in advance. This is prepared for the Sender interface for the sake of simplicity.
[0063]
The SenderImpl class is a concrete class that implements the Sender interface. It has an object receiver implementing a receiver interface as an instance variable, and issues an API call to this. In both callOldAPI () and callNewAPI (), the character strings given as parameters are passed to receiver # oldAPI () and receiver # newAPI (), and the API is called, and the synthesized character string returned as a result is output as standard. .
[0064]
According to the present invention, a client-side program using the callOldAPI () receives a receiver. Without changing the logic for calling the old API (String, String) (that is, while maintaining compatibility), the function extension is automatically supported such that the receiver, new API (String, String, String) is called after the API extension.
[0065]
The changeAPI () method of the SenderImpl class has a function of defining and registering an alternative process for the old API. This method does not need to be defined in the client program. Here, it is defined in SenderImpl for simplicity of description, but it can be implemented in a third party program by changing the method of defining the Executable implementation object.
[0066]
In this example, for the method “callOldAPI” of the “Sender” class, an alternative process “register an alternative process X of Receiver # oldAPI () to the alternative process management unit” is defined and registered. . At the same time, as an alternative process X to the “oldAPI” method of the “Receiver” class, an alternative process of “call a callNewAPI (String, String, String) method” is defined and registered.
[0067]
The main () method of the SenderImpl class is an example showing how to use the present invention. First, create an object as a proxy class to hook the method call. Next, as a process before changing the old API, sender. callOldAPI () and sender. Calls callNewAPI (). Outputs the concatenation of the given parameter strings. Then, by calling the above-mentioned SenderImpl # changeAPI (), sender. callOldAPI () and the receiver. Create and register an alternative process for the two old APIs of oldAPI ().
[0068]
After this API change, sender. callOldAPI () and sender. Calls callNewAPI (). The operation is in the following sequence.
[0069]
sender. Since the execution of the callOldAPI () is hooked by the method invocation handler and executed instead of the alternative process, the above-described “register the alternative process X of the Receiver # oldAPI () with the alternative process management unit” is executed. Is done.
[0070]
At the same time, sender. receiver.call, which is the original process of callOldAPI (). The oldAPI () process is executed, and this process is also executed in place of the above-described alternative process X: “call the callNewAPI (String, String, String) method”, and as a result, sender. This means that the callNewAPI () has been executed.
[0071]
At this time, sender. In callOldAPI (), two parameters are passed, but sender. The third parameter of the callNewAPI () is ServerImpl. this. It is completed by a process called getZ (). This is the operation given by the definition of the Executable implementation object defined in ServerImpl # changeAPI ().
[0072]
Eventually, sender. The processing of callOldAPI () is performed without changing the calling format at all. Since it is executed in place of callNewAPI (), the effect of combining three character strings is obtained. At the same time, the original sender. As a result, a character string output combined with the processing result of callOldAPI () itself is obtained.
[0073]
On the other hand, sender. callNewAPI () and receiver. Since the new API () does not define an alternative process, these activations are executed as they are.
[0074]
Next, FIG. 6 is a conceptual diagram showing a definition example of the Executable interface. As the only essential method, it is necessary to implement public object execute (Object [] args) throws Exceptions; it is used for defining alternative processing. It is searched for in an alternative process management class described later, and is activated by issuing the execute () method.
[0075]
Apply the Command design pattern and define an object that implements the Executable interface, or use new Executable () {public Object execute (Object [] args)} / * as anonymous class object as logic of the new API function * / { Implement alternative processing.
[0076]
Next, FIG. 7 shows an implementation example of an alternative processing management class. FIG. 8 shows one implementation example of the method activation handler.
[0077]
According to the above-described embodiment, the client simply executes the code for calling the old API without any change, and instead, the process corresponding to the new API is executed at the meta level, and as a result, the compatibility of the API is maintained. Function expansion becomes possible as it is.
[0078]
Further, the function of the server 10 or the function of the client 20 is realized by executing a program stored in a storage unit (not shown). The storage unit is configured by a nonvolatile memory such as a hard disk device, a magneto-optical disk device, or a flash memory, a volatile memory such as a RAM (Random Access Memory), or a combination thereof. In addition, the above-mentioned storage unit is, for example, a volatile memory (RAM) in a computer system serving as a server or a client when a program is transmitted through a network such as the Internet or a communication line such as a telephone line, for a certain period of time. Including those holding programs.
[0079]
Further, the above program may be transmitted from a computer system storing the program in a storage device or the like to another computer system via a transmission medium or by a transmission wave in the transmission medium. Here, the “transmission medium” for transmitting a program refers to a medium having a function of transmitting information, such as a network such as the Internet or a communication line such as a telephone line. Further, the program may be for realizing a part of the processing described above. Further, what is called a difference file (difference program) that can realize the above-described processing in combination with a program already recorded in the server 10 or the client 20 may be used.
[0080]
As described above, the embodiment of the present invention has been described in detail with reference to the drawings. However, the specific configuration is not limited to the above embodiment, and includes a design and the like within a range not departing from the gist of the present invention. .
[0081]
【The invention's effect】
As described above, according to the present invention, since the program of both the server and the client using the old API is not modified, it is possible to easily and flexibly realize the function expansion while maintaining the compatibility. The advantage that it can be obtained is obtained. Also, the test work is simplified because the test program is not changed. In addition, during execution of a plurality of programs that cooperate via the old API, it is possible to add, change, or delete an alternative process corresponding to the old API. Behavior can be changed dynamically. As a result, the modification to the cooperating program itself is minimized, and it is easy to implement and test the function extension. This has the advantage of improving the program development efficiency and productivity. can get.
[Brief description of the drawings]
FIG. 1 is a conceptual diagram showing an operation and an effect of a program function extension according to an embodiment of the present invention.
FIG. 2 is a conceptual diagram showing a means for implementing a program function extension according to the present embodiment together with a specific example.
FIG. 3 is a block diagram showing a functional configuration for implementing a program function extension according to the embodiment;
FIG. 4 shows an implementation example of a receiver object in a server program.
FIG. 5 is a conceptual diagram showing one implementation example of a Sender object in a client program.
FIG. 6 is a conceptual diagram showing one implementation example of a Sender object in a client program.
FIG. 7 is a conceptual diagram illustrating a definition example of an Executable interface.
FIG. 8 is a conceptual diagram illustrating an implementation example of an alternative processing management unit.
FIG. 9 is a conceptual diagram showing an implementation example of a method activation handler.
[Explanation of symbols]
10. Server program
20 client programs
30 old API call protocol
40 Old API function
50 New API Function
100 Alternative processing management unit
110 Alternative processing search unit
111 Alternative processing registration unit
112 Alternative processing update unit
113 Alternative processing deletion unit
114 Alternative Processing Search / Execution Unit
115 Alternative Processing Synthesis / Execution Unit
200 Alternative processing object definition part
300 client program
400 server program
500 Method start handler part
201 Alternative processing object definition part
301 Client program section
401 server program section
501 Method start handler part
1000 language processing execution system

Claims (9)

A program function expansion system that manages the cooperation of a plurality of programs that cooperate via an API, and extends an old API function to a new API function while maintaining API compatibility when changing an API that is a protocol between programs. ,
An alternative processing management means for dynamically registering, changing, and deleting an alternative processing object corresponding to a method object implementing the old API function during execution of a plurality of programs that cooperate via the old API function;
An alternative processing object obtaining means for searching and obtaining an alternative processing object using the method object of the old API function as a key by using the alternative processing managing means in the meta-level processing for controlling activation and execution of the old API function;
An alternative processing object executing means for executing the alternative processing object acquired by the alternative processing object acquiring means instead of executing the old API function while maintaining consistency between the additional information accompanying the API extension and the return information from the API; and ,
A program function extension system, comprising: a fusion process execution unit that executes a process in which a substitution function and an old API function are merged when the substitution process object execution unit executes the substitution process object. 2. The program function extension system according to claim 1, wherein the alternative processing management means is realized by a hash table that stores the old API processing object and the new API processing object in association with each other as keys. The alternative processing management means searches the new API processing object using the old API processing object as a key, and if the value corresponding to the key is empty, executes the old API processing as it is and returns the result. 3. The program function extension system according to claim 2, wherein when the value to be executed is not empty and a new API processing object is assigned, the new API processing object is taken out and a message for executing an alternative process is issued. . 3. The program function expansion system according to claim 2, wherein said alternative process management means is configured based on a Singleton design pattern. A program function extension method for managing cooperation of a plurality of programs that cooperate via an API and extending an old API function to a new API function while maintaining API compatibility when changing an API that is a protocol between programs. ,
During execution of a plurality of programs that cooperate via the old API function, an alternative processing object corresponding to a method object implementing the old API function is dynamically registered / changed / deleted,
In meta-level processing for controlling activation and execution of the old API function, search and acquire an alternative processing object using the method object of the old API function as a key,
Executing the acquired alternative processing object in place of the execution of the old API function while maintaining the consistency between the additional information accompanying the API extension and the return information from the API,
A method of extending a program function, wherein, in the execution of the alternative process object, a process that combines an alternative function and an old API function is executed. A program function extension method for managing cooperation of a plurality of programs that cooperate via an API and extending an old API function to a new API function while maintaining API compatibility when changing an API that is a protocol between programs. ,
Using the reflection function provided in the programming language processing execution system, when calling a method that implements the old API function, transfer control to the meta-level processing, intercept the execution of the old method at the meta-level, and create a new method corresponding to the old method object. And executing the new method in place of the old method in the meta level processing. 7. The method according to claim 6, wherein an old API processing object that realizes a function corresponding to the old API and a new API processing object that realizes a function corresponding to the new API are managed in association with each other. Dynamically registering / changing / deleting an alternative processing object corresponding to a method object implementing the old API function during execution of a plurality of programs that cooperate via the old API function;
Searching and acquiring an alternative processing object by using a method object of the old API function as a key in a meta-level process for controlling activation and execution of the old API function;
Executing the acquired alternative processing object instead of executing the old API function while maintaining consistency between additional information accompanying the API extension and return information from the API;
A program function expansion program for causing a computer to execute a step of executing a process combining an alternative function and an old API function in the execution of the alternative process object. Dynamically registering / changing / deleting an alternative processing object corresponding to a method object implementing the old API function during execution of a plurality of programs that cooperate via the old API function;
Searching and acquiring an alternative processing object by using a method object of the old API function as a key in a meta-level process for controlling activation and execution of the old API function;
Executing the acquired alternative processing object instead of executing the old API function while maintaining consistency between additional information accompanying the API extension and return information from the API;
A recording medium characterized by recording a program function extension program for causing a computer to execute a step of executing a process combining an alternative function and an old API function in the execution of the alternative process object.

Images