JP3577714B2 - System using program execution method - Google Patents

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a program execution method for distributing and operating a program via a network and a system using the same, and in particular, a program execution method capable of executing various programs with high flexibility and a system using the same. About.
[0002]
[Prior art]
Conventional program execution methods for distributing and operating a program via a network are roughly classified into two types. That is, a method of distributing and executing the program file to the user's machine, and a method of dynamically operating the program on the memory of the user's machine.
[0003]
As the former method, for example, a program file is transferred to a user's machine using file transfer software such as FTP (File Transfer Protocol) and executed, or the user downloads a program file from a Web server using a browser. And run.
[0004]
In the latter method, for example, a program execution part is downloaded from a Web server to a memory of a user's machine and executed by a dynamic program execution command from the user.
[0005]
FIG. 9 is a configuration block diagram showing an example of a program operation method using the Java (Apple, an object-oriented interpreter language developed by Sun Microsystems; a trademark or registered trademark of Sun Microsystems), which is the latter method. In FIG. 9, 1 is a Web server, 2 is a machine such as a computer existing at a server site, 3 is a client machine, and 4 is a machine existing at a client site. Reference numeral 50 denotes a server site, and 51 denotes a client site.
[0006]
When a dynamic program execution instruction is issued from the user side, an applet such as "AP01" in FIG. 9 is downloaded from the Web server 1 to the memory of the client machine 3 as shown in "DL01" in FIG. Being working.
[0007]
Currently, the system itself can flexibly respond to changes in various situations, in other words, it is possible to execute any program remotely and immediately, and it is possible to add the functions you want to use as needed Therefore, there is a need for a program execution method and a system using the same, which can immediately delete used functions.
[0008]
[Problems to be solved by the invention]
However, in the former conventional example described above, there is a problem that a used program file remains in the client machine. Further, in the latter conventional example, there is a problem that the operation of the browser is unstable or the communication destination of the applet is limited to the Web server, and the flexibility is lacking.
[0009]
For example, an applet executed on the memory of the client machine 3 indicated by “AP02” in FIG. 9 can only communicate with the Web server 1 indicated by “AE01” in FIG. 9, and “AD01” in FIG. The local disks of “AD02” and “AD03” existing on the server site 50 side, the machine 4 existing on the client site 51 side, and the client machine 3 itself cannot be accessed.
[0010]
That is, even when an applet is used, there is a problem that it is difficult to immediately execute an arbitrary program remotely and to add / delete a desired function as needed.
Therefore, an object of the present invention is to realize a program execution method capable of operating various programs with high flexibility and a system using the same.
[0011]
[Means for Solving the Problems]
In order to achieve such an object, the invention according to claim 1 of the present invention is:
In a system using a program execution method of distributing and operating a class via a network,
pluralSaid class;pluralCommunication with the classRespectivelyDopluralUser interface classOne-to-one correspondenceManagement and based on the generation request from the process running on the client machineOne of the above classesA server for downloading and executing a class during a process, and communicating with the server andOne-to-one correspondence with the one classA client machine that downloads and executes the user interface class during a process and communicates with the class via the user interface class to operate various programs with high flexibility It becomes possible to do.
[0012]
The invention according to claim 2 is
In a system using a program execution method of distributing and operating a class via a network,
pluralSaid class;pluralCommunication with the classRespectivelyDopluralUser interface classOne-to-one correspondenceBased on the request to generate from the server to be managed and the process running on the client machineOne of the above classesA remote machine that downloads and executes classes during the process, communicates with the server, andOne-to-one correspondence with the one classA client machine that downloads and executes the user interface class during a process and communicates with the class via the user interface class to operate various programs with high flexibility It becomes possible to do.
[0013]
The invention according to claim 3 is
In a system using a program execution method of distributing and operating a class via a network,
pluralSaid class;pluralCommunication with the classRespectivelyDopluralUser interface classOne-to-one correspondenceA stored web server,pluralThe class andpluralBased on a management server that performs registration management of the user interface class and a generation request from a process running on a client machineOne of the above classesA remote machine that downloads and executes classes during a process, and communicates with the management server and from the web serverOne-to-one correspondence with the one classA client machine that downloads and executes the user interface class during a process and communicates with the class via the user interface class to operate various programs with high flexibility It becomes possible to do.
[0014]
The invention according to claim 4 is
In the system according to any one of claims 1 to 3,
Said class,
Class for remote diagnosis of equipment provided in the systemThis allows remote diagnosis of the device.
[0015]
The invention according to claim 5 is
In the system according to any one of claims 1 to 3,
Said class,
Class for data analysis displayThus, a data viewer can be obtained.
[0016]
The invention according to claim 6 is
In the system according to any one of claims 1 to 3,
Said class,
System inspection classThereby, system startup inspection and periodic inspection can be performed.
[0017]
The invention according to claim 7 is
In the system according to any one of claims 1 to 3,
Said class,
Class that gives instructions to each device provided in the system or class that monitors devices provided in the systemThereby, wide area monitoring and abnormality processing can be performed.
[0018]
The invention according to claim 8 is
In the system according to the second or third aspect,
The client machine and the remote machine,
Having a cache for storing the downloaded user interface class and the class and related informationThus, traffic concentration on the network can be reduced.
[0019]
The invention according to claim 9 is
In the system according to claim 8,
The client machine is
Using the user interface class stored in the cache until the set time elapses if the user interface class exists in the cacheThus, traffic concentration on the network can be reduced.
[0020]
The invention according to claim 10 is
In the system according to the ninth aspect,
The client machine is
When using the user interface class stored in the cache, transmitting the information to the remote machine via a server that manages the class and the user interface class.This prevents the user interface class and the class having different versions from being activated between the client machine and the remote machine.
[0028]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, the present invention will be described in detail with reference to the drawings. FIG. 1 is a configuration block diagram showing one embodiment of a system using a program execution method according to the present invention. In FIG. 1, 5 is a management server, 6 is a Web server, 7 is a client machine, and 8 and 9 are remote machines.
[0029]
The management server 5, Web server 6, client machine 7, and remote machines 8 and 9 are mutually connected by a network (not shown).
[0030]
Here, the operation of the embodiment shown in FIG. 1 will be described. The management server 5 executes “Worker” (hereinafter simply referred to as “Worker”), which is a program indicated by “WA11”, “WA12” and “WA13” stored in the Web server 6 in FIG. Have 8 and 9 download.
[0031]
At the same time, a user who communicates with a worker indicated by “WG11”, “WG12”, and “WG13” in FIG. 1 stored in the Web server 6 to give an instruction from a user or displays data from the worker An interface program “WorkerGUI” (hereinafter simply referred to as “WorkerGUI”) is downloaded to the client machine 7.
[0032]
Then, the user virtually executes the worker on the client machine 7 by communicating with the worker running on the remote machines 8 and 9 using the worker GUI dynamically executed on the client machine 7. be able to.
[0033]
As a result, the used program file does not remain in the client machine 7, and it is possible to operate various programs with high flexibility by selecting a worker executed on the remote machines 8 and 9. .
[0034]
Further, the operation of the embodiment shown in FIG. 1 will be described in detail with reference to FIGS. 2, 3, 4, 5, and 6. FIG. FIG. 2 is an explanatory diagram for explaining the registration of the worker and the worker GUI, etc., FIG. 3 is a flowchart for explaining the operation of the client machine 7, FIG. 4 is a flowchart for explaining the operation of the management server 5, and FIG. 9 is a flowchart illustrating the operation of FIG.
[0035]
However, in the following description, “WG11” and “WA11” are handled as class files instead of the program body.
[0036]
In FIG. 2, 5 and 6 and “WG11”, “WG12”, “WG13”, “WA11”, “WA12” and “WA13” are assigned the same reference numerals as those in FIG. 1, and 10 is the development of the Walker and the WalkerGUI. Machine.
[0037]
The administrator previously assigns various Worker classes that may be used by the client created on the machine 10 to the WorkerManager, which is a management program running on the management server 5, as indicated by “NR21” in FIG. register. Also, as shown by “UL21” in FIG. 2, a class pair of a worker class and a corresponding worker GUI class is stored in the web server 6.
[0038]
First, in the client machine 7, at "S001" in FIG. 3, the client machine 7 starts a WorkerManager GUI, which is a pre-installed process for performing communication with the WorkerManager running on the management server 5.
[0039]
In “S002” in FIG. 3, the client machine 7 selects a worker class to be used from the worker classes registered in the worker manager via the worker manager GUI, selects a remote machine to download the worker class to, and requests the worker manager to generate the worker machine. I do.
[0040]
For example, as shown by “RQ11” in FIG. 1, the worker manager is selected so that the class of “WA11” and “WA12” in FIG. 1 is downloaded to the remote machines 9 and 8, respectively.
[0041]
In “S003” in FIG. 3, the client machine 7 is notified of the address of the Web server 6 that is the storage destination of the worker GUI class corresponding to the selected worker class from the worker manager. The client machine 7 accesses the web server 6 at this address to change the worker GUI class. Download the class in the WorkerManager GUI.
[0042]
For example, as shown by “DL11” in FIG. 1, the worker GUI classes “WG11” and “WG12” in FIG. 1 corresponding to “WA11” and “WA12” in FIG. The class is downloaded in the WorkerManager GUI shown in "."
[0043]
In "S004" in FIG. 3, the client machine 7 generates an instance in the worker manager GUI and starts the worker GUI, and starts communication with the worker running on the remote machine in "S005" in FIG. Processing is performed appropriately.
[0044]
For example, “WG11 ′”, which is a Wooker GUI activated as shown by “MC11” in FIG. 1, communicates with “WA11 ′”, which is a Worker activated on the remote machine 9, and “WG11” in FIG. As shown in MC12 ”,“ WG12 ′ ”, which is a worker GUI activated, communicates with“ WA12 ′ ”, which is a worker activated on the remote machine 8.
[0045]
Further, in the management server 5, in "S101" in FIG. 4, the management server 5 starts a WorkerManager that manages the class of the Worker. Then, in “S102” in FIG. 4, it is determined whether or not a request for generation of a worker has been received from the worker manager GUI operating on the client machine 7.
[0046]
If a request for generation of a worker is received from the worker manager GUI in “S102” in FIG. 4, the management server 5 in “S103” in FIG. 4 transmits the request of the worker selected as the class download destination from the worker manager GUI to the remote machine. Instruct generation.
[0047]
For example, as shown by "IW11" and "IW12" in FIG. 1, the remote machine 9 or 8 is notified of the name of the worker class to be downloaded and the address of the web server 6 where the worker class is stored.
[0048]
In "S104" in FIG. 4, the management server 5 notifies the address of the Web server 6, which is the storage destination of the WickerGUI class corresponding to the selected Worker class.
[0049]
Finally, in the remote machines 8 and 9, in step "S201" in FIG. 5, a worker space, which is a process for providing a worker operation area, is started. For example, the remote machine 9 starts a worker space such as “WS11” in FIG. 1, and the remote machine 8 starts a worker space such as “WS12” in FIG.
[0050]
Then, in “S202” in FIG. 5, the remote machines 8 and 9 determine whether or not there has been an instruction to generate a Worker from the WorkerManager, and if there has been an instruction to generate the Worker, the worker specified in “S203” in FIG. Download the class into the WorkerSpace.
[0051]
For example, a worker class name to be downloaded from a worker manager and an address of a web server 6 where the worker class is stored are notified, and the worker classes “WA11” and “WA12” in FIG. 1 are transmitted to the remote machines 9 and 8, respectively. Consider a case where an instruction to download a class is given.
[0052]
The remote machine 9 downloads the worker class indicated by “WA11” in FIG. 1 from the Web server 6 to the worker space indicated by “WS11” in FIG. 1 as indicated by “DL12” in FIG.
[0053]
Similarly, the remote machine 8 downloads the worker class indicated by “WA12” in FIG. 1 from the Web server 6 to the worker space indicated by “WS12” in FIG. 1, as indicated by “DL13” in FIG.
[0054]
Then, in “S204” in FIG. 5, the remote machines 8 and 9 respectively generate instances in the worker space and start the respective workers, and communicate with the worker GUI running on the client machine 7 in “S205” in FIG. To start.
[0055]
For example, as shown by “MC11” in FIG. 1, “WA11 ′” which is a started worker on the remote machine 9 communicates with “WG11 ′” which is one of the started WorkerGUIs on the client machine 7. As shown by “MC12” in FIG. 1, the activated worker “WA12 ′” on the remote machine 8 communicates with the activated other worker GUI “WG12 ′” on the client machine 7. Perform communication.
[0056]
In other words, by operating the WorkerSpace on the remote machine, various types of Worker classes can be dynamically downloaded and the Worker can be started, so that it is not necessary to install various programs on the remote machine each time.
[0057]
In addition, if only the WorkerManager GUI is installed on the client machine 7, various classes of the WorkerGUI can be dynamically downloaded to communicate with the worker operating on the remote machine, so that various programs can be operated with high flexibility. It becomes possible to do.
[0058]
Further, since the WorkerManager and the corresponding WorkerGUI class are managed as a pair by the WorkerManager, version consistency between the remote machine and the client machine is guaranteed.
[0059]
Further, as an application example of the embodiment shown in FIG. 1, the following can be considered.
(1) Remote diagnosis of equipment
(2) Data viewer
(3) Automatic distribution of programs
(4) System startup inspection and periodic inspection
(5) Wide area monitoring and error handling
[0060]
Regarding “(1) Remote diagnosis of device”, a computer or the like for operating a WorkerSpace is connected to the device and various Workers for remote diagnosis are prepared. The user can download a worker corresponding to the abnormality of the device to the computer or the like and diagnose the device.
[0061]
In this case, it is not necessary to install various diagnostic programs on the remote computer or the like, and the remote diagnosis can be performed by downloading the Worker only when necessary. In other words, a low-spec computer can perform sufficient diagnosis.
[0062]
Further, even if a new diagnostic worker is separately developed, it can be used in the existing environment. Further, even if the devices are separately installed, remote diagnosis can be performed collectively by connecting these devices to one computer.
[0063]
As for “(2) Data Viewer”, a computer or the like connected to a database on the remote side and operating a WorkSpace is provided, and various Workers for data analysis and display are prepared. The user can download a Worker that satisfies the format desired to be displayed on the device to the computer or the like and extract data in a desired format.
[0064]
Even in this case, there is no need to install various data analysis programs in a remote computer or the like, and it is possible to download the Worker only when necessary and extract data in a desired format. In other words, a low-spec computer can perform sufficient diagnosis. Further, even when a new data analysis display worker is separately developed, it can be used in the existing environment.
[0065]
Regarding “(3) Automatic distribution of program”, by setting an operation time limit for a worker itself to distribute to a user, a worker that operates for a certain period of time can be distributed to the user. Further, by giving the contract manager information to the worker manager, the worker can be distributed only to the contract user.
[0066]
FIG. 6 is a configuration block diagram showing an example of such a program distribution. In FIG. 6, 5a is a management server, 6a is a Web server, 10a is a machine for development, etc., 11 is a Web server for advertisement, and 12 and 13 are client machines. 52 indicates a development company, 53 indicates a Worker management center, and 54 and 55 indicate users.
[0067]
The management server 5a, the Web servers 6a and 11, and the client machines 12 and 13 are mutually connected by a network (not shown).
[0068]
Here, an application example shown in FIG. 6 will be described. However, description of the same parts as those in FIG. 1 will be omitted. The worker and the worker GUI developed by the development company 52 are stored in the Web server 6a of the worker management center 53 as shown by "UL21" and "NR31" in FIG. 6, and are registered in the worker manager operating on the management server 5a. You.
[0069]
On the other hand, the specifications of the developed Worker and the WorkerManager GUI are published on the advertising Web server 11 of the development company 52, and the interested user downloads the WorkerManager GUI appropriately, installs it on the user's client machine, and starts it.
[0070]
Then, it accesses the management server 5a of the worker management center 53, downloads the class of the worker GUI class, and uses the worker started on the remote machine.
[0071]
For example, the user 55 downloads, installs, and starts the worker manager GUI indicated by “WMG2” in FIG. Then, the user accesses the management server 5a of the worker management center 53 to download and use the worker GUI and worker indicated by “WG31” and “WA31” in FIG.
[0072]
In addition, for example, the user 55 downloads the worker manager GUI indicated by “WMG2” in FIG. 6 from the web server 11 to the client machine 13, installs the same, and starts up. Then, it is also possible to access the management server 5a of the worker management center 53, download only the worker GUI indicated by "WG31" in FIG. 6, and use the worker started on the remote machine.
[0073]
In this case, even when the user is using the program, the worker GUI and the worker indicated by “WG31” and “WA31” in FIG. 6 stored in the management server 5a of the worker management center 53 can be updated as needed. Therefore, maintenance work such as updating can be performed even while the user is using it.
[0074]
On the other hand, the user can always use the latest program when downloading only the Worker GUI such as “WG31” in FIG.
[0075]
Further, in a system as described below, the worker GUI is downloaded at the time of startup, and if many users download at the same time, there is a problem that the traffic on the network increases.
[0076]
For example, when this system is applied to an automatic teller machine (ATM) of a bank, a download of the Worker GUI occurs at the same time as the business start time.
[0077]
In this case, "ReloadID" indicating the download permission time is set in the client machine, and a cache for storing the downloaded WorkerGUI class, class name, and storage location information of the WorkerGUI class is provided.
[0078]
For example, as “ReloadID”, times such as “10:30”, “11:30”, and “12:30” are set, and the traffic on the network is dispersed and set on average. . Of course, the set times may overlap.
[0079]
On the other hand, the remote machine on which the selected worker is executed is provided with a cache for storing the downloaded worker class, class name, and storage location information of the worker class.
[0080]
Then, the client machine and the remote machine store the above information and the like in their respective caches when the Worker GUI class and the Worker class are downloaded.
[0081]
Here, the operations of the client machine and the remote machine will be described with reference to FIGS. FIG. 7 is a flowchart illustrating the operation of the client machine, and FIG. 8 is a flowchart illustrating the operation of the remote machine. However, since the basic operation has already been described, the description of that part will be omitted.
[0082]
In "S301" in FIG. 7, the client machine selects a worker to be used. At this time, in "S302" in FIG. 7, it is determined whether or not the WorkerGUI class corresponding to the selected Worker is stored in the cache of the client machine.
[0083]
If the worker GUI exists in the cache of the client machine, the client machine compares the current time with “ReloadID” set in the client machine in “S303” in FIG. 7 and determines that the current time is “ReloadID”. It is determined whether or not the set time has passed.
[0084]
If the current time has not passed the set time of “ReloadID”, the client machine informs the WorkerManager of the storage location information of the WorkerGUI stored in the cache in “S304” in FIG.
[0085]
When requesting a remote machine to generate a worker, the worker manager notifies the remote machine of the storage location of the worker corresponding to the storage location information of the worker GUI obtained from the client machine.
[0086]
Then, in "S305" in FIG. 7, the client machine copies the worker GUI class in the cache into the worker manager GUI.
[0087]
On the other hand, when the worker GUI does not exist in the cache of the client machine in “S302” in FIG. 7, and when the set time of “ReloadID” has elapsed in “S303” in FIG. 7, “S306” in FIG. In "", the client machine downloads the class of the WorkerGUI class into the WorkerManager GUI.
[0088]
Finally, in “S307” in FIG. 7, the client machine generates an instance in the WorkerManager GUI and activates the WorkerGUI.
[0089]
On the other hand, in “S401” in FIG. 8, the remote machine determines whether or not there has been an instruction to generate a Woker from the WokerManager. It is determined whether the worker class whose generation has been instructed is stored.
[0090]
If the worker whose generation is instructed exists in the cache of the remote machine, the remote machine copies the worker class in the cache into the worker space in "S403" in FIG.
[0091]
If the worker whose generation has been instructed does not exist in the cache of the remote machine, the remote machine downloads the class of the worker into the worker space in “S404” in FIG.
[0092]
Finally, in “S405” in FIG. 8, the remote machine generates an instance in the WorkerSpace and activates the Worker.
[0093]
That is, in the client machine, the worker GUI class corresponding to the worker used for the cache is stored, and the stored worker GUI is used until the set time of “ReloadID” elapses. Can be alleviated.
[0094]
Similarly, when the remote machine stores the generated and retired worker class in the cache, the use of the worker can reduce traffic concentration on the network.
[0095]
Further, even when the version of the Worker GUI and the worker on the Web server are upgraded, the fact that the use of the worker GUI in the cache is transmitted to the remote machine by the worker manager on the client machine, so that different versions of the worker GUI are used between the client machine and the remote machine. And Walker are prevented from being activated.
[0096]
Regarding “(4) System startup inspection and periodic inspection”, the worker space is operated on the system, and an inspection program necessary only at the time of starting the system and a periodic inspection program not used in normal operation are prepared as a worker.
[0097]
Even in this case, there is no need to install various inspection programs on the system side, and the designated inspection can be performed by downloading the Worker only when necessary. Further, even if a new inspection worker is separately developed, it can be used in the existing environment.
[0098]
Regarding “(5) Wide-area monitoring and abnormality processing”, in the field of wide-area monitoring and ITS (Intelligent Transport Systems), a sensor device or an actuator device capable of operating Java or Java having an interface with such a device. Equipment that can operate is widely arranged. On the other hand, a worker for instructing each device and a worker for monitoring devices are prepared.
[0099]
Then, the monitor can download the worker to each device as necessary and remotely monitor and instruct.
[0100]
In the embodiment shown in FIG. 1, for the sake of simplicity, the management server 5 on which a WorkerManager operates, the Web server 6 on which a Worker class and a WorkerGUI class are stored, and the remote machines 8 and 9 on which a WorkerSpace operates However, if the conditions of network traffic and machine specifications permit, all roles may be aggregated in one machine or roles may be integrated.
[0101]
For example, the management server 5 and the Web server 6 may be integrated, or the Web server 6 and the remote machines 8 and 9 may be integrated.
[0102]
Further, in the embodiment shown in FIG. 1, the worker class and the worker GUI class are described as a one-to-one pair, but the present invention is not limited to this. For example, by preparing a plurality of worker GUI classes for one worker class, the flexibility of appropriately selecting a GUI corresponding to the specifications of the client machine is improved.
[0103]
【The invention's effect】
As is apparent from the above description, the present invention has the following effects.According to the first, second and third aspects of the present invention,By operating WorkerSpace on the remote machine, various types of Worker classes can be dynamically downloaded and the Worker can be started, so that it is not necessary to install various programs on the remote machine each time.
[0104]
Also, if only the WorkerManager GUI is installed on the client machine, various classes of the WorkerGUI can be dynamically downloaded to communicate with the worker operating on the remote machine, so that various programs can be operated with high flexibility. It becomes possible.
[0105]
Further, since the WorkerManager and the corresponding WorkerGUI class are managed as a pair by the WorkerManager, version consistency between the remote machine and the client machine is guaranteed.
[0108]
Also,The invention of claims 4 to 7According to the above, by appropriately selecting the type of program, remote diagnosis of equipment, data viewer, automatic distribution of program, system startup inspection and periodic inspection, wide area monitoring, processing of abnormality, and the like can be performed.
[0109]
Also,Claims 8 and 9According to the above, the client machine and the remote machine are provided with a cache for storing the downloaded user interface class and the class and the related information, and use the user interface program stored in the cache until a set time elapses. Thus, traffic concentration on the network can be reduced.
[0110]
Also,The invention of claim 10According to the above, the client machine transmits the user interface class stored in the cache to the remote machine via a server that manages programs and the like, whereby the client machine and the remote machine have different versions. The user interface class and the class are prevented from being activated.
[Brief description of the drawings]
FIG. 1 is a configuration block diagram showing an embodiment of a system using a program execution method according to the present invention.
FIG. 2 is an explanatory diagram illustrating registration of a worker and a worker GUI, and the like.
FIG. 3 is a flowchart illustrating the operation of the client machine.
FIG. 4 is a flowchart illustrating the operation of the management server.
FIG. 5 is a flowchart illustrating the operation of the remote machine.
FIG. 6 is a configuration block diagram illustrating an example of program distribution.
FIG. 7 is a flowchart illustrating the operation of the client machine.
FIG. 8 is a flowchart illustrating the operation of the remote machine.
FIG. 9 is a configuration block diagram illustrating an example of a program operation method using a Java applet.
[Explanation of symbols]
1,6,6a, 11 Web server
2,4,10,10a machine
3,7,12,13 Client machine
5,5a Management server
8, 9 remote machine
50 server sites
51 client sites
52 Development Company
53 Worker Management Center
54,55 users

Claims (10)

In a system using a program execution method of distributing and operating a class via a network,
A plurality of said classes, of the plurality of classes based on the generated request from a process running on the client machine while managing a plurality of user interface classes for performing communication each of the plurality of classes is one-to-one correspondence and servers that run the class download one of the class in the process,
Communicates with the server, downloads and executes the user interface class corresponding to the one-to-one class from the server in a process, and communicates with the class via the user interface class. And a client machine for performing. In a system using a program execution method of distributing and operating a class via a network,
And the plurality of classes, and a server for managing a plurality of user interface classes for performing communication each of the plurality of classes is one-to-one correspondence,
A remote machine that downloads and executes a class of one of the plurality of classes during the process based on a generation request from a process running on the client machine;
Communicates with the server, downloads and executes the user interface class corresponding to the one-to-one class from the server in a process, and communicates with the class via the user interface class. And a client machine for performing. In a system using a program execution method of distributing and operating a class via a network,
And the plurality of classes, and the Web server and a plurality of user interface classes for communicating with a plurality of said classes each of which is stored in correspondence with one-to-one,
A management server that performs registration management of the plurality of classes and the plurality of user interface classes;
A remote machine that downloads and executes a class of one of the plurality of classes during the process based on a generation request from a process running on the client machine;
Communicates with the management server and downloads and executes the user interface class corresponding to the one class on a one-to-one basis during the process from the web server, and executes the class via the user interface class. And a client machine that communicates with the client. Said class,
  It is a class for remote diagnosis of equipment provided in the system.
The system according to claim 1. Said class,
  It is a class for data analysis display
The system according to claim 1. Said class,
  Characterized as a system inspection class
The system according to claim 1. Said class,
  It is a class that gives an instruction to each device provided in the system or a class that monitors devices provided in the system.
The system according to claim 1. The client machine and the remote machine,
  And a cache for storing the downloaded user interface class and the class and related information.
A system according to claim 2 or claim 3. The client machine is
  When the user interface class exists in the cache, the user interface class stored in the cache is used until a set time elapses.
The system according to claim 8. The client machine is
  When using the user interface class stored in the cache, the information is transmitted to the remote machine via a server that manages the class and the user interface class.
The system according to claim 9.

Images