JP2001147812A - Class generation method, object generation method, interface object generation method, and object execution system - Google Patents

Abstract

(57) [Summary] To provide an object execution system capable of transferring an object from a client host to a server host at the time of execution and executing the object remotely. SOLUTION: An object 61 specified by a user program is transferred from a client host 1 to a server host (11, 12, 31), and a remote object 7 corresponding to the object 71 transferred on the server host 3 is transmitted.
1 is generated (32), and a class of an interface object for remotely calling the remote object is generated on the client host 1 based on the object 71 and the remote object identifier notified from the server host 3 (14). An interface object 62 is generated from the generated class, and an object identifier indicating the generated interface object is returned to the user program.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to a method for generating a class for generating a new class, a method for generating an object for generating an object of a new class, a method for generating an interface object for remotely executing an object, and a method for generating an interface object. The present invention relates to an object execution system for remotely executing an object.

[0002]

2. Description of the Related Art Conventionally, there has been a distributed object technology based on a remote procedure call as a method of using a resource or a program on a remote host in an object-oriented programming language environment. This technology includes a stub object that can be directly operated from a program, a remote object running on another host, and a means for operating a remote object prepared in the stub. The computer on which the stub object runs is called a client host, and the computer on which the remote object runs is called a server host. Also, remote objects are sometimes called server objects.

[0003] This conventional distributed object technology is based on relationships between static objects. For this reason, the remote object on the server host side had to be created statically. That is, the remote object on the server host and the stub object on the client host corresponding to the remote object have their interfaces and behavior determined statically at design time, expressed in a programming language, and if necessary, After being compiled into an executable, it ran on server and client hosts. It should be noted that the interface referred to here is information in which an identifier of a method that the object discloses to the outside and a number of arguments received by the method are set. Furthermore, in the case of an object-oriented programming language in which a class is treated as a type, the class of an object that is an argument or a return value is also an element that constitutes an interface. This interface is also called an external interface of the object.

Therefore, in the conventional distributed object technology as described above, it is difficult to transfer an arbitrary object selected at the time of execution from a client host to a server host and use it.

In order to realize such a use method, for example, a method of generating a remote object and an interface object for all objects existing on the client host in advance may be considered. However, in this method, all elements of the program are defined twice and executed on the server host and the client host, and it is practically difficult to realize when the scale of the program becomes large ( It is very difficult to run those programs).

[0006]

As described above, in the conventional distributed object technology, it is difficult to select an arbitrary object at the time of execution and transfer the object from the client host to the server host for use.

The present invention has been made in view of the above circumstances, and provides a class generation method for generating a new class at execution and an object generation method for generating an object of a new class at execution. The purpose is to:

Further, the present invention transfers an arbitrary object selected from a program on a client host to a server host at the time of execution so that the transferred object on the server host can be operated from the program on the client host. It is an object to provide an interface object generation method and an object execution system.

[0009]

Means for Solving the Problems The present invention (claim 1) provides:
A class generation method for generating a new class when a program described in an object-oriented programming language is executed, comprising: a class identifier of an object indicated by a specified object identifier; Obtain interface information consisting of a pair of an interface including a method identifier and an argument type of the method, generate a new class, and, for the generated class, add the interface information obtained from the object to the interface. The method is characterized in that a new class is generated by declaring a method that duplicates the interface of the object based on the above, and declaring data as needed.

According to the present invention, a class having a new behavior at the time of execution can be generated from an existing object.

[0011] The present invention also relates to a class generating method for generating a new class when executing a program described in an object-oriented programming language,
From the object indicated by the specified object identifier, the interface information including a class identifier of the object and a set of an interface including a method identifier of the object and an argument type of the method is acquired. Generate a derived class of the class indicated by the class identifier, and for the generated derived class, declare a method that duplicates the interface of the object based on the interface information obtained from the object,
A new class is generated by declaring data as needed.

According to the present invention, a class having a new behavior at the time of execution can be generated from an existing object.

The object generating method according to the present invention (claim 2) is characterized in that a new object is generated from a new class generated by the class generating method according to the present invention.

According to the present invention, an object of a class having a new behavior at the time of execution can be generated from an existing object.

According to the present invention (claim 3), when a program described in an object-oriented programming language is executed, an object indicated by an object identifier designated by a user program on the client host is transferred from the client host to the server host. An interface object generation method for generating an interface object for invoking a remote method of the object on a client host in order to remotely execute the object, comprising: Acquiring interface information including a class identifier and a set of an interface including an identifier of a method of the object and an argument type of the method; Obtaining a remote object identifier indicating a remote object generated on the server host by the transfer to the server host from the server host, generating a derived class of the class indicated by the obtained class identifier, For this derived class, based on the interface information acquired from the object, the same method identifier as the method identifier of the object, the same interface as the interface of the object, and the remote object identifier By declaring a method having a method process for performing a method call for the same method identifier and declaring the remote object identifier as data, a class of an interface object is generated, and the generated From the class of interface objects, and generates the interface object.

Preferably, an object identifier indicating the generated interface object may be returned to the user program.

Preferably, when transferring the object from the client host to the server host, serializing the object on the client host side, transferring the serialized object from the client host to the server host, The transferred serialized object may be restored on the host side.

Preferably, when transferring the object from the client host to the server host, the class of the object may also be transferred.

Preferably, when transferring the object from the client host to the server host,
Whether or not to transfer the object class may also be determined by a predetermined class selection method.

According to the present invention (claim 8), when a program described in an object-oriented programming language is executed, an object indicated by an object identifier specified by a user program on the client host is transferred from the client host to the server host. Means for transferring an object indicated by an object identifier designated by a user program from the client host to the server host, the object execution system corresponding to the object transferred on the server host. Means for generating a remote object to execute, the remote host indicating on the client host the object indicated by the object identifier and the remote object notified from the server host. Means for generating a class of an interface object for remotely invoking the remote object based on the object identifier, means for generating an interface object from the generated class of the interface object, and an object indicating the generated interface object Means for returning an identifier to the user program.

Preferably, the means for generating a class of the interface object includes, from an object indicated by the specified object identifier, a class identifier of the object, a method identifier of the object, and an argument of the method. Means for obtaining interface information consisting of a set with an interface including a type, and obtaining from the server host a remote object identifier indicating a remote object generated on the server host by transferring the object to the server host; Means for generating a derived class of the class indicated by the obtained class identifier, and a method of the object with respect to the generated derived class based on the interface information obtained from the object. A method having the same method identifier as the identifier, the same interface as that of the object, and a method process for performing a method call for the same method identifier of the remote object identifier is declared. Means for generating a class of the interface object by declaring it as data.

The present invention (claim 10) is a class generation program for generating a new class when an application program described in an object-oriented programming language is executed. And interface information comprising a set of a class identifier of the object and an interface including a method identifier of the object and an argument type of the method, and obtains a derived class of the class indicated by the obtained class identifier. Generated, and for this generated derived class,
Based on the interface information obtained from the object, declare a method that duplicates the interface of the object, and declare data as necessary, thereby recording a class generation program for generating a new class. Computer-readable recording medium.

According to the present invention, at the time of execution, an object can be transferred from a client host to a server host, a remote object corresponding to the server host can be generated, and an interface object corresponding to the client host can be generated. It is possible to remotely execute the object transferred from the server to the server host. As a result, the user program can select an arbitrary object at the time of execution, transfer the object to another computer, and remotely control the computer. This makes it possible to flexibly construct or execute a system using distributed objects.

The present invention relating to the apparatus is also realized as an invention relating to a method, and the present invention relating to a method is also realized as an invention relating to an apparatus.

The present invention relating to an apparatus or a method is provided for causing a computer to execute a procedure corresponding to the present invention (or for causing a computer to function as means corresponding to the present invention, or for causing a computer to correspond to the present invention). The present invention is also realized as a computer-readable recording medium in which a program for realizing the function of performing the above is recorded.

[0026]

Embodiments of the present invention will be described below with reference to the drawings.

The terms "class" and "object" used below have basically the same meanings as those used in general object-oriented languages.

FIG. 1 shows an example of the overall configuration of a client host and a server host constituting a remote object execution control system according to an embodiment of the present invention. As shown in FIG. 1, a client host 1 and a server host 3 are connected by a communication path 2 (communication is possible). Although FIG. 1 shows only a pair of a client host and a server host, a client host and a server host may also be connected.

The client host 1 and the server host 3 are computers provided with an environment for executing the objects (61, 62, 71, 72). Client host 1
Is a computer operated directly by a user program (not shown), and is a computer on which the interface object (62) runs. On the other hand, the server host 3 is a computer on which the remote object (72) and its main object (71) run.

The "remote object (72)" means that the desired object 61 is transferred (or copied) from the client host 1 to the server host 3 for remote execution (as a result of this transfer, This is an object generated in correspondence with the transferred object 71, and is one form of the object generated in the server host 3.

"Interface object (62)"
Is an object generated corresponding to the remote object (72) for remote execution of the desired object 61, and is a form of the object generated in the client host 1.

The remote object (72) and the interface object (62) provide the same functions as the skeleton object and the stub object used in the conventional distributed object technology.

That is, in the client host 1, the user program can directly operate the interface object (62). The interface object (62) operates the corresponding object via the corresponding remote object (72) in the server host 3 according to a request from the user program. As a result, the client host 1 can indirectly remotely control the corresponding object via the interface object (62) and the corresponding remote object (72).

It should be noted that the client host and the server host are concepts to be described separately in a certain situation between a computer operating as a client host and a computer operating as a server host. Of course, a system to which the present invention is applied is constructed. In some cases, there may be a case where a certain computer doubles as a client host and a server host (that is, one host may have only the function of either the client host or the server host; It may have the functions of both the client host and the server host, or they may be mixed.)

As shown in FIG. 1, a client host 1 receives an object identifier specified by a user program, and delivers the object identifier to a serialized object transmitting mechanism 12 and an interface object generating mechanism 14. A serialized object transmitting mechanism 12 for serializing an object indicated by an object identifier and transferring the object indicated by the object identifier via a communication channel, and a remote object identifier receiving mechanism for receiving a remote object identifier passed from the server host 3 13 and an interface object generation mechanism 14 that receives the object 61 indicated by the object identifier and the remote object identifier and generates an interface object 62.

The server host 3 is connected to the client host 1
Receiving the serialized object passed from the remote object, restoring the object from the serialized object, and passing the object identifier indicating the object to the remote object generating mechanism 32, receiving the serialized object receiving mechanism 31 and the object identifier, And a remote object identifier transmitting mechanism 33 for transferring a remote object identifier indicating the remote object generated by the remote object generating mechanism 32 to the client host.

The remote method calling mechanism to be provided in the client host 1 and the server host 3 is as follows:
For example, an existing one may be used.

According to such a configuration, an arbitrary object can be selected at the time of execution, and the object can be transferred from the client host 1 to the server host 3 and executed.

In addition to the above configuration, the client host 1 is further provided with a class transmitting mechanism 15 for receiving the class identifier passed from the server host 3 and transferring the class indicated by the class identifier. The class 5 existing in the server host 3 itself based on the class identifier specified by the serialized object receiving mechanism 31
1 or class 4 existing on client host 1
In the case where any one of the methods 1 is selected and the class 41 existing in the client host 1 is selected, a class receiving mechanism 34 for transferring a class identifier indicating the class may be further provided. This makes it possible to generate a remote object even when a class is not prepared in the server host 3 in advance.

In the above description, the object is transferred from the client host 1 to the server host 3 using the object serialization / restoration processing. However, another object transfer means may be used.

Each mechanism in FIG. 1 can be realized by software.

Hereinafter, the present embodiment will be described in more detail.

Here, a case where an object-oriented technique based on a class widely used in an object-oriented programming language is generally used will be described as an example. That is, the declaration of an object is performed in a class serving as a template, and a program is realized by generating an object from the class. Of course, the present invention is also applicable and effective when using an object-oriented language based on a prototype in which the object is a template of the object.

FIG. 2 shows a more detailed overall configuration example of a client host and a server host constituting the remote object execution control system according to the present embodiment.

The client host 1 comprises a remote object creation and management mechanism 101, an object serialization mechanism 10
2. It includes a serialized object transmission mechanism 103, a remote object identifier reception mechanism 110, a remote method call transmission mechanism 121, and a class transfer transmission mechanism 134 (a configuration not including the class transfer transmission mechanism 134 as described above is also possible). .

The server host 3 includes a serialized object receiving mechanism 305, a serialized object restoring mechanism 306, a remote object generating mechanism 307, a remote object identifier transmitting mechanism 308, and a remote method call receiving mechanism 32.
3. Class selection mechanism 331, class transfer reception mechanism 332
Shall be included.

Of course, as described above, the class selection mechanism 3
31, the class transfer receiving mechanism 332, and the class transfer transmitting mechanism 134 may not be included (here, the case where they are included will be described as an example).

The mechanism of FIG. 2 can be realized by software. The mechanism shown in FIG. 2 can be provided as, for example, library software.

Here, the case where the object serialization processing / restoration processing is used to transfer the object from the client host 1 to the server host 3 will be described as an example, but as described above, the transfer of another object is performed. Means may be used.

The object 161 is an object specified by a user program as a target for remote execution on the server host.

The object 171 is the object 16
1 is transferred (or copied) from the client host 1 to the object 161.

The remote object 172 is an object generated corresponding to the object 171.

The interface object 162 is an object generated corresponding to the remote object 172.

The communication mechanisms 204, 209, 222,
Reference numeral 233 denotes a communication network or the like for performing communication between the client host 1 and the server host 3. The communication network includes a communication mechanism provided in the client host 1, a communication mechanism provided in the server host 3, and a communication path. Become. Also, 4
The two communication mechanisms 204, 209, 222, 233 may be the same. In the following, for the sake of simplicity, the communication mechanism will be described without dividing it into parts.

First, an outline of the phase of transferring an object and generating a remote object and an interface object will be described.

The remote object generation and management mechanism 101
An object identifier is received from the user program on the client host 1, and the object serializer 10
2 and the interface object generation mechanism 111.

The object serializer 102 serializes the object 161 indicated by the object identifier and generates serialized data.

The serialized object transmission mechanism 103 converts the serialized data into a network representation format in a communication channel, and further adds communication protocol data. In addition,
Any communication path can be applied. For example, the communication protocol may be a protocol up to a network layer or a higher layer, or a protocol up to a data link layer.

The above data is transferred from the client host 1 to the server host 3 by the communication mechanism 204.

The serialized object receiving mechanism 305 receives and extracts communication protocol data and serialized data from the communication mechanism 204.

The serialized object restoration mechanism 306 creates an object 171 from the serialized data.

The remote object generation mechanism 307 receives the object identifier and generates a remote object 172.

Remote object identifier transmission mechanism 308
Receives the remote object identifier, converts it to a network representation, and adds communication protocol data.

The above data is transferred from the server host 3 to the client host 1 by the communication mechanism 209.

Remote object identifier receiving mechanism 110
Receives the remote object identifier in the network representation form from the communication mechanism 209 and extracts the remote object identifier.

Interface object generation mechanism 11
1 receives the remote object identifier and the object identifier, generates an interface object 162, and returns it to the user program.

Next, the outline of the remote method calling phase will be described.

The remote method call transmission mechanism 121
The client host 1 receives a method identifier, a remote object identifier, and method argument data from a user program, converts them into a network representation format, and adds communication protocol data.

The above data is transferred from the client host 1 to the server host 3 by the communication mechanism 222.

The remote method call receiving mechanism 323 includes:
The remote object identifier, the method identifier, and the method argument data are received from the communication mechanism 222, and the method is called to the remote object. Then, the remote method call receiving mechanism 323 converts the return value into a network expression format, and further adds communication protocol data.

The above data is transferred from the server host 3 to the client host 1 by the communication mechanism 222.

The remote method call transmission mechanism 121
The return value is received from the communication mechanism 222 and returned to the requesting user program.

Next, an outline of the class selection phase will be described.

Here, it is assumed that the class on the client host 1 is 141 and the class on the server host 3 is 151.

The class selecting mechanism 331 receives the class identifier from the serialized object restoring mechanism 306 for restoring the transferred serialized object, and receives the class 151 existing in the server host 3 or the class 141 returned from the class transfer receiving mechanism 332. One of them is selected, and a response is returned to the serialized object restoring mechanism 306.

This selection is made by the client host 1
A method that is performed after the class is obtained from the client side and a method that is performed before the class is obtained from the client host 1 side are considered. In the latter case, the relevant class is obtained from the client host 1 only when it is determined that the class obtained from the client host 1 is to be used.

When acquiring a class from the client host 1, the class selecting mechanism 331 passes the class identifier to the class transfer receiving mechanism 332.

Upon receiving the class identifier, the class transfer receiving mechanism 332 generates a network expression format of the class identifier and communication protocol data.

The above data is transferred from the server host 3 to the client host 1 by the communication mechanism 233.

The class transfer / transmission mechanism 134 is the communication mechanism 2
When the class identifier and the communication protocol data in the network expression format are received from 33, the class identifier is extracted and the network expression format and the communication protocol data of the class (141) indicated by the class identifier are generated.

The data is transferred from the client host 1 to the server host 3 by the communication mechanism 233.

The class transfer receiving mechanism 332 is a communication mechanism 2
When the class (141) is received from 33, it is returned to the class selection mechanism 331.

By adding such a configuration,
Either the class 151 of the server host 3 or the class 141 of the client host 1 can be selected and used.

FIG. 3 shows a configuration example of a general object used in the present embodiment.

The object (160) has a class identifier (160) indicating a class serving as a model of the object.
3), a method table (1601) and a data table (1602).

The method table (1601) includes a method identifier (16011) and an interface (1601).
2) and 0 or more sets of methods (16012) are held.

The method (16012) may store the code itself, or may store a pointer to a memory in which the code is stored.

The data table (1602) holds zero or more sets of data identifiers (16021) and data (16022).

The data (16022) may store the value itself, or may store a pointer to a memory in which the value is stored.

One interface (16012) is:
It is composed of a class identifier of an object of zero or more arguments and a class identifier of an object to be a return value. It should be noted that the interface information is a method identifier and an interface that are all sets existing in a certain object.

In the case of a remote object, a corresponding object, for example, FIG.
, Pointer information (for example, an object identifier) to the object 171 transferred from the client host 1 to the server host 3 is set. In the data (16022) and method (16012) items,
The pointer information to the corresponding object (171) is described.

In the case of an interface object, pointer information (for example, a remote object identifier) to a corresponding remote object, for example, the remote object 172 in FIG. 2, is set in the data table (1602). Method (160
In item 12), pointer information to the corresponding remote object (172) is described.

Next, the interface object generating mechanism 111 and the interface object will be described.

FIG. 4 shows a more detailed configuration example of the interface object generation mechanism 111 in the present embodiment.

Interface object generation mechanism 11
Reference numeral 1 denotes an interface acquisition mechanism 1111 for extracting a class identifier indicating the class and interface information from the object indicated by the object identifier passed from the remote object generation management mechanism 101, the class identifier and the interface information, and a remote object identifier reception mechanism. A class generation mechanism 1113 for declaring a class (163) of an interface object as a new class from the remote object identifier (1624) passed from 110, and an object for generating an interface object (162) from the declared class (163) A generation mechanism 1112 is included. Class generation mechanism 11
Reference numeral 13 denotes a data declaration mechanism 1115 for declaring data (1632) of a new class based on the remote object identifier (1624), and a method declaration mechanism 1114 for declaring a method (1631) of the new class based on the interface information. including.

Here, it is desirable that the class (163) of the interface object declared as a new class in the interface object generating mechanism 111 inherits the base class. This is the object of the return value to the user program, that is, the interface object (162) when inheritance is used.
Can be treated as the base class,
This is because the user program is not particularly conscious of the interface object (162) and the remote object (172). That is, if the programming language has an expression format that can handle the class as a type, the class of the object of the argument requested to be generated as the remote object (172) and the remote object (17
The class of the object of the return value which is the interface object (162) functioning as an interface to 2) is the same. Note that, in a general object-oriented language, such a type conversion relating to a reference between classes having an inheritance relationship is provided as a cast operation, and a user program converts an interface object of the present embodiment into an It is possible to hold using the type of.

Next, a processing procedure when a remote object is generated will be described.

FIG. 5 shows an example of a processing procedure when a remote object is generated in this embodiment.

A communication mechanism (204, 20) for providing communication between the server host 3 and the client host 1.
9, 222, 233) have been initialized in advance. That is, it is assumed that transmission from a certain mechanism of the server host 3 can be received by a certain mechanism of the client host 1, and communication in the opposite direction is also possible.

The procedure of FIG. 5 will be described below step by step.

The remote object creation management mechanism 101 of the client host 1 receives an object identifier indicating the object (161) to be transferred to the server host 3 from the user program.

The remote object generation management mechanism 101 stores the passed object identifier in the object serialization mechanism 102 and the interface object generation mechanism 11.
1 (step S1).

The object serializer 102 refers to the object from the passed object identifier, extracts the class identifier of the object and the internal state of the object, that is, the value of the data, and sets it as serialized data (step S2). . Next, the serialized data is passed to the serialized object transmission mechanism 103.

The serialized object transmitting mechanism 103 that has received the serialized data converts the serialized data into a network representation format and creates communication protocol data. Next, the communication protocol data and the serialized data are
The information is passed to the communication mechanism 204.

The communication mechanism 204 having received the communication protocol data and the serialized data transmits the data to the server host 3 (step S3).

Data is received from the communication mechanism 204 (step S4). Serialized object receiving mechanism 305
Verifies the communication protocol, and if a communication error occurs (step S5), performs error processing. on the other hand,
If no communication error has occurred (step S
5) Return the serialized data from the network representation format to the original format (step S6). Next, the serialized data is passed to the serialized object restoration mechanism 306.

Upon receiving the serialized data, the serialized object restoring mechanism 306 restores an object from the serialized data. The object identifier of the restored object is passed to the remote object generation mechanism 307.

The remote object generation mechanism 307 generates a remote object from the object indicated by the passed object identifier and the remote object identifier (step S7). The remote object identifier indicating the generated remote object is delivered to the remote object identifier transmitting mechanism 308.

Remote object identifier transmission mechanism 308
Converts the passed remote object identifier into a network representation format and creates communication protocol data. Next, the communication protocol data and the converted remote object identifier data are passed to the communication mechanism 209.

The communication mechanism 209 having received the communication protocol data and the remote object data transmits the data to the client host 1 (step S8).

The data is received from the communication mechanism 209 (step S9). The remote object identifier receiving mechanism 11
0 verifies the communication protocol. If a communication error occurs (step S10), error processing is performed. On the other hand, if no communication error has occurred (step S
10) Return the remote object identifier data from the network representation format to the original format. Next, the remote object identifier is stored in the interface object generation mechanism 111.
Pass to.

Interface object generation mechanism 11
1 generates an interface object (step S11) and returns it to the user application.

Next, the procedure for generating an interface object will be described.

FIG. 6 shows an example of the processing procedure of the interface object generating mechanism 111.

Hereinafter, the procedure of FIG. 6 will be described step by step.

The object identifier passed from the remote object generation management mechanism 101 to the interface object generation mechanism 111
Passed to 1. Also, the remote object identifier receiving mechanism 110 sends the interface object generating mechanism 111
Are passed to the class generation mechanism 1113.

The interface acquiring mechanism 1111 extracts a class identifier and interface information from the object indicated by the object identifier (step S2).
1). The interface information is a method identifier and an interface that are all sets existing in a certain object. Next, the class identifier and the interface information are transferred to the class generation mechanism 1113.

The class generating mechanism 1113 generates a new class as a derived class of the class indicated by the passed class identifier (step S22). Here, this newly generated class is referred to as a child class. next,
The remote object identifier and the class identifier indicating the child class are passed to the data declaration mechanism 1115. After that, the interface information and the class identifier indicating the child class are passed to the method declaration mechanism 1114 in order to add a method to the class indicated by the passed class identifier.

The data declaration mechanism 1113 declares the passed remote object identifier as child class data (step S23). Next, the data identifier of the data indicating the remote object identifier is stored in the method declaration
Pass to.

The method declaration mechanism 1114 extracts one set of a method identifier and an interface from the passed interface information (step S24). next,
A method process for calling the same method identifier as the extracted method identifier, the same interface as the extracted interface, and the same method identifier of the remote object identifier indicated by the data identifier passed from the data declaration mechanism 1115; Are declared in the class indicated by the class identifier (step S25).

This is executed for all pairs of method identifiers and interfaces (step S26).

Thus, the declaration of the new class is completed. The newly declared class becomes the class of the interface object.

The class identifier indicating the created class is
Deliver to the object generation mechanism 1112.

The object generation mechanism 1112 generates a new object from the class indicated by the passed class identifier (step S27). That is, an interface object is generated.

Finally, an object identifier indicating the generated interface object is returned to the user program.

Next, the procedure of the method call will be described.

FIG. 7 shows an example of a procedure for calling a method of a remote object via an interface object in the present embodiment.

Hereinafter, the procedure of FIG. 7 will be described step by step.

In the client host 1, the method of the interface object called from the user program refers to the method of the method to the remote object indicated by the remote object identifier held in the interface object, as described in the remote object generation flow. Make a call. Therefore, calling a method on an interface object is
This is a method call to the remote object identifier.
Hereinafter, a detailed execution procedure of this flow will be described.

The user program stores a method identifier and 0
At least one argument object is specified and the method of the interface object is called (step S
31).

In the method of the called interface object, it is described that the method of the remote object having the same interface as the called method is called for the remote object indicated by the remote object identifier held as data. (Step S32). The specific processing of this description is as follows. The interface object transmits a remote object identifier, a method identifier, and an object serving as zero or more arguments to the remote method call transmission mechanism 12.
Pass to 1.

The remote method call transmission mechanism 121
Passed remote object identifier, method identifier and 0
More than two objects as arguments are converted into a network expression format, and further, communication protocol data is added and passed to the communication mechanism 222.

The communication mechanism 222 transmits the passed data and the communication protocol data to the server host (Step S33).

The remote method call receiving mechanism 323 on the server host 3 receives, from the communication mechanism 222, the communication protocol data, the remote object identifier in the network representation format, the method identifier, and zero or more arguments as objects (step S34). ).

The communication protocol data is verified, and if a communication error occurs, error processing is performed.

On the other hand, if no communication error has occurred, the received remote object identifier, method identifier, and zero or more argument objects are returned from the network expression format to the original format.

Next, a call is executed for the method indicated by the method identifier of the remote object indicated by the remote object identifier while designating zero or more objects as arguments (step S35).

Next, the remote object call receiving mechanism 323 receives an object which is a return value returned as a result of the method call for the remote object. The return object is converted into a network expression format, and communication protocol data is loaded and passed to the communication mechanism 222.

Communication mechanism 22 that has received communication protocol data and a return value object in network representation format
2 transmits the data to the client host (step S36).

Upon receiving the communication protocol data and the return value object converted into the network representation form from the communication mechanism 222 (step S37), the remote method call transmission mechanism 121 verifies the communication protocol data, and if a communication error occurs. Performs error processing.

On the other hand, if no communication error has occurred, the return value object is returned from the network expression format to the original format.

The return value object is passed to the interface object.

The interface object returns a return value object to the user program as a return value of the result of the method call (step S38).

Next, the class transfer processing procedure will be described.

FIG. 8 shows an example of a processing procedure relating to class transfer when a remote object is generated in this embodiment.

Hereinafter, the procedure of FIG. 8 will be described step by step.

From the serialized object restoration mechanism 306,
The class selection mechanism 331 to which the class identifier has been passed checks whether or not the class indicated by the class identifier exists in the server host.

If the class exists in the server host (step S41), the class is returned to the serialized object restoring mechanism 306 (step S42).

On the other hand, if the class does not exist in the server host (step S 41), the class identifier is passed to the class transfer receiving mechanism 332.

The class transfer receiving mechanism 332 that has received the class identifier converts the class identifier into a network expression format, adds communication protocol data, and adds the communication protocol data.
Pass to.

The communication mechanism 233 transmits the passed data to the client host 1 (Step S43).

The class transfer transmitting mechanism 134 on the client host 1 verifies the received communication protocol data (step S44), and performs an error process if a communication error occurs.

On the other hand, if no communication error has occurred, the class identifier in the network expression format is returned to the original format. Next, the class indicated by the class identifier is converted into a network expression format, and the protocol is added to the communication protocol data and passed to the communication mechanism 233 (step S45).

The communication mechanism 233 transmits the passed data to the server host 3 (Step S6).

The class transfer receiving mechanism 332 is a communication mechanism 2
The communication protocol data and the class of the network representation format are received from the communication device 33 (step S47), the communication protocol data is verified, and if an error occurs, error processing is performed. On the other hand, if no communication error has occurred,
The class is returned from the network expression format to the original format, and the class is returned to the serialized object restoration mechanism 306 (step S48).

Note that a method of instructing a class selection method in advance at the time of initialization of the class selection mechanism 331 may be considered. In this case, the class selection mechanism 331 uses the class in the server host or the class transfer reception mechanism 332 in accordance with the specified class selection method instead of whether or not the class exists in the server host. Decide whether to transfer and use the class that exists in the client.

Thus, by preparing different classes for the server and the client, it becomes possible to realize different behavior between the original object on the client and the remote object transferred to the server.
For example, by defining a class that accesses resources or processes unique to each computer and performing object transfer according to the present invention, it is possible to use resources or processes specific to each computer from different computers. Can be easily constructed.

Alternatively, by selecting class transfer, it is possible to construct a distributed system in which computer resources such as a network bandwidth and a secondary storage area are optimized.

In the above description, when the remote object is generated, the object is transferred from the client host 1 to the server host 3. However, an object already existing on the server host 3 side can be used. That is, it is also possible to perform only generation of a remote object, transmission and reception of a remote object identifier, and generation of an interface object in the present embodiment without transferring an object from the client host 1 to the server host 3. For example, in the case of the configuration example of FIG. 2, the object serialization mechanism 102, the serialized object transmission mechanism 103, and the serialized object reception mechanism 305
And the remote object generation and management mechanism 101, the remote object generation mechanism 307, and the remote object identifier transmission mechanism 308 without using the
And a remote object identifier receiving mechanism 110 and an interface object generating mechanism 111.

As a result, an interface object can be generated for an object already existing on the server host 3 side, and by passing through this interface object, the client host 1
From the above program, the object on the server host 3 can be operated.

In order to realize such an operation, the following modification is made to the processing procedure for transferring an object from the client host 1 to the server host 3 at the time of generation of a remote object as described above. Just do it.

That is, the remote object generation management mechanism 101 requests the remote object generation mechanism 307 to return a remote object identifier via the communication mechanism 204 without performing the serialization procedure. The remote object generation mechanism 307 generates a remote object based on the identifier indicating the object already existing on the specified server host 3 side, and passes the remote object identifier indicating the remote object to the transmission mechanism 209.

Further, the interface object generating mechanism 111 which has received the remote object identifier changes the class of the object from which it is based on the class existing on the client host 1 side or the above-described mechanism 331, 332, 134 relating to class transfer. The roles of the client host 1 and the server host 3 are reversed and read from the class on the server host.

With the above change, it is possible to generate an interface object on the client host 1 side with respect to an existing object existing on the server host 3 side.

It should be noted that (1) it is possible to adopt a configuration in which objects can only be transferred from the client host 1 to the server host 3 and executed remotely.
It is possible to adopt a configuration in which only existing objects on the side can be used, or (3) a configuration in which they can be arbitrarily selected. Can eliminate the object serializing mechanism 102, the serialized object transmitting mechanism 103, the serialized object receiving mechanism 305, and the serialized object restoring mechanism 306 (in the case of FIG. 1, the serialized object transmitting mechanism 12 and the serialized object transmitting mechanism 12). (The serialized object receiving mechanism 31 can be omitted.)

Hereinafter, a general system configuration to which the present invention is applied will be described from the viewpoint of a user program.

FIG. 9 shows a system configuration centered on objects. That is, as shown in FIG. 9, a computer 1001 serving as a client host and a computer 1003 serving as a server host of the present embodiment can communicate with each other.
A user program 1011, an object 1012, and an interface object 1013 exist on the client host 1001, and a remote object 1031 exists on the server host 1003. Note that FIG.
Although the mechanism described in etc. also exists on each computer,
They are omitted in FIG.

Here, the user program 1011 on the client host 1 designates an object 1012, and assigns the object 1012 to the server host 100.
If the remote object 1031 is to be executed on the client host 1001, a remote object 1031 must be generated on the server host 1003, and an interface object 1013 for making the remote object 1031 usable from a program must be generated.

This function is provided by the interface object generation mechanism of the present embodiment. With the use of the interface object generation mechanism, it is possible to dynamically generate an interface object. That is, the user program can generate or select an arbitrary object during its execution, and transfer and use the object to the server host.

Here, an example of a call on a virtual language for making a function type procedure call using the above configuration will be shown, and the ease of description according to the present invention will be described.

In a language such as the following: object A; A = object (); (The first line is a variable A of the object type.
The second line constructs an object type,
A), according to the present embodiment, the variable A
Is transferred to the server host.

According to the present invention, as described below, a server host (note that the server host identification information is
An instruction for easily transferring an object of the object type indicated by A can be described above. The object indicated by B is an interface object. In addition, an arbitrary object is used for A, and is used as an arbitrary host server (ServerHos).
t). object B; B = A. createRemoteObject (S
or a language such as the following: object B; B = System. createRemoteObject
ct (A, ServerHost); The first line is a declaration of an object type variable B, and the second line is the creation of a remote object.
The difference between the two types of descriptions is the difference in the form of generation of the remote object.

When the conventional distributed object technology is used, the interface object B of A is
Although it was necessary to compile in advance, according to the present embodiment, B can be generated as a derived class of A at the time of execution by the interface object generating mechanism.

When the interface object B of the above code example is used, method (); (Note that the above description is based on the method
od).

Thus, the remote object on the server host (ServerHost) generated by the above code example can be called via the interface object B.

As is apparent from these code examples, the use of this embodiment makes it possible to easily generate a remote object or use a remote object in a conventional programming language.

In the following, application examples of the present embodiment will be described.

The present embodiment can be applied to, for example, remote maintenance, monitoring and control of a device located in a remote place or a control device with scarce computer resources. Objects can be transferred from a maintenance client computer or a monitoring / control computer. The data is transferred to the target device, and the computer serving as the client host can perform maintenance, monitoring, and control of the remote device serving as the server host via this object.

FIG. 10 shows a configuration example of the present system including a remote device. In FIG. 10, reference numeral 1101 denotes a maintenance client computer, which corresponds to a client host;
Reference numeral 1105 denotes a monitoring / control computer, which corresponds to a client host. 1103 denotes a remote device to be maintained, which corresponds to a server host. Also, the maintenance client processing mechanism 11011 and the remote monitoring control mechanism 1
1051 corresponds to the user program in the above description.

For example, when the maintenance client processing mechanism 11011 requests remote execution of an object on the remote device side, the following procedure is performed. (1) The object 11012 having the maintenance function is transferred from the maintenance client computer 1101 to the remote device 1103, and the remote object 11031 is generated. (2) The maintenance client computer 1101
An interface object 11013 is generated on the own computer. (3) The maintenance client computer 1101
A maintenance processing request is sent to the remote object 11031 on the remote device 1103 via the interface object 11013. (4) The remote object 11031 is the remote device 1
The maintenance process is performed in cooperation with the device control mechanism 1103 of the computer 103, and the result is returned to the maintenance client computer 1101.

In this embodiment, a plurality of maintenance processes can be sent to a remote object via an interface object, unlike a mechanism that simply transfers the process and returns the execution result. For this reason, it is possible to perform another processing according to the object returned as a result of the method call of the remote object, or to perform maintenance processing interactively.

Further, communication between the remote device (server host) and the computer (client host) can be performed by an interface object and a remote object corresponding to the maintenance work. For this reason, it is possible to reduce the communication load as compared with a method using a communication method defined in advance.

Further, by deleting the remote object at the stage when the maintenance is completed, it becomes possible to save computer resources.

The same applies to monitoring and control.

For example, when the monitoring / control computer 1105 requests remote execution of an object on the remote device side, the following procedure is performed. (1) An object 1 having a monitoring / control function from the monitoring / control computer 1105 to the remote device 1103
Transfer 1052 and create remote object 11032. (2) The monitoring / controlling computer 1105 generates an interface object 11053 on its own computer. (3) The monitoring / control computer 1105 sends a maintenance processing request to the remote object 1103 on the remote device 1103 via the interface object 11053.
Send to 32. (4) The remote object 11032 is the remote device 1
The monitoring and control process is performed in cooperation with the device control mechanism 1103 of 103, and the result is returned to the monitoring and control computer 1105.

In this way, it becomes possible to request the remote object via the interface object for processing and monitor and control the remote device. Further, it is possible to add / change the function relating to the monitoring / control from the client host side.

In the example of FIG. 10, the maintenance client computer and the monitoring / control computer are described separately, but of course, the maintenance computer and the monitoring / control computer are shared by one computer. It does not matter.

In this embodiment, for example, a CGI (Common Gateway In) in a WWW server is used.
server processing such as terface) and servlet,
The present invention is also applicable to a system in which another server performs distributed processing.

FIG. 11 shows a configuration example of the present system including a server computer.

In FIG. 11, reference numeral 1200 denotes a request source computer for requesting a service from a server, 1201 denotes a main server computer server, which corresponds to a client host;
03 and 1204 are first and second secondary server computers, which correspond to server hosts. 12001 is a server processing request mechanism, 12011 is a main server request processing mechanism, and 12042 is a secondary server specific processing mechanism. The number of secondary server computers may be one or three or more. Usually, there are a plurality of requesting computers.

The system shown in FIG. 11 includes a main server computer 1201 for receiving a request for server processing, and a plurality of secondary server computers 120 for actually performing a part or all of the processing.
In a computer environment in which the objects 12012 and 12014 on the main server computer 1201 are connected to the secondary server
3, 1204, the main server computer 120
Part or all of the processing performed on the server 1
03,1204.

That is, (1) It is assumed that objects 12012 and 12014 for performing server processing are arranged in the main server computer 1201, and the main server 1201 computer
2012 and 12014 to the secondary server computers 1203 and 12
04 and transferred to remote objects 12031 and 1204
1 is generated. (2) The main server computer 1201 generates interface objects 12013 and 12015 on its own computer. (3) The main server computer 1201 responds to the processing request by
One or more processing requests are sent to the secondary server computer 12 via the interface objects 12013 and 12015.
03,1204 remote objects 12031,12
041 to send the processing to the secondary server computer 120.
3,1204. (4) The remote objects 12031 and 12041 on the secondary server computers 1203 and 1204 process the processing requests from the interface objects 12013 and 12015 in accordance with the definition of the objects.

In this embodiment, the load on the main server computer can be reduced by transferring the object for server processing from the main server computer to another sub server computer.

Further, since the main server computer can make a processing request to a remote object on the sub server computer via the interface object, one server process can be divided into a plurality of processing requests. For example, it is possible to cause the remote object to perform another process again based on the processing result of the remote object. For this reason, a process according to a complicated state can be performed as compared with a case where the process is simply transmitted.

Further, since objects for performing server processing do not need to be arranged on a plurality of secondary server computers in advance, the addition / change of objects may be performed only on the main server computer, and the management of a plurality of distributed servers can be performed. It will be easier.

Furthermore, even if one server process is completed, the remote object and the interface object are left on each server computer, so that the same remote object can perform a process that covers a plurality of server process requests.

On the other hand, the storage area on the secondary server computer can be saved by appropriately discarding the remote object for which the request processing has been completed.

Further, the remote object can perform processing using data and devices existing only on the secondary server computer by making a processing request to another object arranged in advance on the secondary server computer.

Although only the object is transferred here, the communication load can be reduced by transmitting the class in advance and using only the data corresponding to the request.

Each of the above functions can be implemented as software.

Further, the present embodiment is a computer in which a program for causing a computer to execute predetermined means (or for causing a computer to function as predetermined means or for causing a computer to realize predetermined functions) is recorded. It can also be implemented as a readable recording medium.

The present invention is not limited to the above-described embodiments, but can be implemented with various modifications within the technical scope.

[0203]

According to the present invention, a class having a new behavior can be generated at the time of execution by using an existing object, and an object of the new class can be generated. .

According to the present invention, at the time of execution, an object can be transferred from a client host to a server host, a remote object corresponding to the server host can be generated, and an interface object corresponding to the client host can be generated. Objects transferred from the host to the server host can be remotely executed.

[Brief description of the drawings]

FIG. 1 is a configuration diagram showing the entirety of the present invention.

FIG. 2 is a diagram showing a configuration of a remote object generation mechanism of the present invention.

FIG. 3 is a diagram showing a detailed configuration of an example of an embodiment of the present invention.

FIG. 4 is a diagram showing a detailed configuration of an interface object generation mechanism of the present invention.

FIG. 5 is a diagram showing a procedure for generating a remote object according to the present invention.

FIG. 6 is a diagram showing a procedure of an operation of the interface object generation mechanism of the present invention.

FIG. 7 is a diagram showing a procedure for calling a method of a remote object via an interface object according to the present invention;

FIG. 8 is a diagram showing a procedure for transferring a class when a remote object is generated according to the present invention.

FIG. 9 is a diagram showing a system configuration for a use form of the present invention;

FIG. 10 is a diagram showing an example in which the present invention is used in a remote device monitoring system.

FIG. 11 is a diagram showing an example in which the present invention is used in a system constructed by distributed servers.

[Explanation of symbols]

1,1001 client host 2 communication path 3,1003 server host 11,101 remote object generation management mechanism 12,103 serialized object transmission mechanism 13,110 remote object identifier reception mechanism 14,111 interface object generation Mechanism 15 Class transmitting mechanism 31, 305 Serialized object receiving mechanism 32, 307 Remote object generating mechanism 33, 308 Remote object identifier transmitting mechanism 34 Class receiving mechanism 41, 51, 141, 151, 163 Class 61, 71,160,161,171,1012,11
012, 11052, 12012, 12014 ... objects 62, 162, 1013, 11013, 11053, 1
2013, 12015 ... interface objects 72, 172, 1031, 11031, 11032, 1
2031, 12041 remote object 102 object serialization mechanism 121 remote method call transmission mechanism 134 class transfer transmission mechanism 204, 209, 222, 233 communication mechanism 306 serialized object restoration mechanism 323 remote method call reception mechanism 332 ... Class transfer receiving mechanism 331 ... Class selection mechanism 1111 ... Interface acquisition mechanism 1112 ... Object creation mechanism 1113 ... Class creation mechanism 1114 ... Method declaration mechanism 1115 ... Data declaration mechanism 1011 ... User program 1101 ... Maintenance client computer 1103 ... Maintenance target remote Equipment 1105 Monitoring / control computer 11011 Maintenance client processing mechanism 11051 Remote monitoring control mechanism 11033 Equipment control Mechanism 1200 ... requesting computer 1201 ... main server computer 1203, 1204 ... secondary server computer 12001 ... server processing request mechanism 12011 ... main server processing request mechanism 12042 ... secondary server-specific processing mechanism

Claims (10)

[Claims] 1. A class generation method for generating a new class when a program described in an object-oriented programming language is executed, comprising: a class identifier of an object indicated by a specified object identifier; And interface information comprising a set of an interface including an identifier of a method of the object and an argument type of the method, a new class is generated, and the generated class is obtained from the object. A method of declaring a method that duplicates an interface of the object based on the interface information, and declaring data as necessary, thereby generating a new class. 2. An object generation method, wherein a new object is generated from a new class generated by the class generation method according to claim 1. 3. When executing a program described in an object-oriented programming language, an object indicated by an object identifier designated by a user program on a client host is transferred from the client host to the server host and remotely executed. An interface object generation method for generating, on a client host, an interface object for invoking a remote method of the object, comprising: a class identifier of the object; a class identifier of the object; Acquires interface information consisting of a pair of an identifier of a method possessed and an interface including an argument type of the method, and sends the object to the server host. Obtains a remote object identifier indicating a remote object generated on the server host by the transfer from the server host, generates a derived class of the class indicated by the obtained class identifier, and generates a derived class for the generated derived class. Based on the interface information obtained from the object, the same method identifier as the method identifier of the object, the same interface as the interface of the object, and the method for the same method identifier of the remote object identifier. Declaring a method having a method process for making a call, and declaring the remote object identifier as data, thereby generating a class of an interface object; Interface object generation method characterized by the class of extract, to produce the interface object. 4. The method according to claim 3, wherein an object identifier indicating the generated interface object is returned to the user program. 5. When the object is transferred from the client host to the server host, the object is serialized on the client host side, and the serialized object is transferred from the client host to the server host. 6. The method according to claim 5, wherein the transferred serialized object is restored on the side. 6. The interface object generating method according to claim 4, wherein when transferring the object from the client host to the server host, an object class is also transferred. 7. When transferring the object from the client host to the server host, whether or not to transfer the class of the object is determined by a predetermined class selection method. 5. The method for generating an interface object according to item 4. 8. An object execution system for remotely executing a program described in an object-oriented programming language by transferring an object indicated by an object identifier designated by a user program on a client host from a client host to a server host. Means for transferring an object indicated by an object identifier designated by a user program from the client host to the server host; and means for generating a remote object corresponding to the transferred object on the server host. On the client host, an object indicated by the object identifier and a remote object identifier indicating the remote object notified from the server host. Means for generating a class of an interface object that makes a remote call to the remote object; means for generating an interface object from the generated class of the interface object; and an object identifier indicating the generated interface object. An object execution system, comprising: means for returning to a program. 9. A method for generating a class of the interface object, comprising: from an object indicated by the specified object identifier, a class identifier of the object, a method identifier of the object, and types of arguments of the method. Means for acquiring interface information consisting of a set with an interface including: and acquiring from the server host a remote object identifier indicating a remote object generated on the server host by transferring the object to the server host; Means for generating a derived class of the class indicated by the obtained class identifier; and, for the generated derived class, the same as the method identifier of the object based on the interface information obtained from the object. And a method having the same interface as the interface of the object, and a method process for performing a method call for the same method identifier of the remote object identifier, and declaring the remote object identifier as data. Means for generating a class of the interface object. 10. A class generation program for generating a new class when an application program described in an object-oriented programming language is executed, wherein a class identifier of an object indicated by a specified object identifier is obtained. And interface information including a pair of an interface including a type of an argument of the method and an identifier of a method of the object, and generating a derived class of the class indicated by the obtained class identifier. For the derived class, declare a method that duplicates the interface of the object based on the interface information acquired from the object, and declare data as needed, thereby creating a new class. Computer-readable recording medium class generation program for generating a.