JP2004265164A - Service cooperation system and service cooperation method between client and server using data transfer protocol - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce the processing load of remote method calling which transfers data having structures, and to reduce a storage capacity in a system construction for executing XML parsing. <P>SOLUTION: This service cooperation system is provided with a client non-cursive data expression generation serializer 230 for converting remote method calling having arguments by a multi-stage structure between a client and a server into a text format constituted at most of one stage hierarchy by assigning an ID pointer. The transferred data in the text format are inverted into the multi-level hierarchy of a programming language by using a server ID pointer table 323 or a server parameter information preparing means 324. Thus, cooperation independent of a programming language between the client and the server or an operating system can be conducted. Also, the hierarchy of the transmitted data is limited to one stage at most so that high speed processing can be performed with a size-reduced and weight-reduced program, and the efficient use of hardware resources such as equipment having no hard disk can be attained. <P>COPYRIGHT: (C)2004,JPO&NCIPI

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a system and a method for performing service cooperation by RPC (Remote Procedure Call) by performing data transfer in a format that can be processed without depending on an OS (operating system) and a programming language, and particularly has a structure. In order to reduce the processing load of remote method calls for transferring data and to reduce the large storage capacity required for building a system for performing XML (Extensible Markup Language) parsing, structured data is used. The present invention relates to a system capable of linking services using a lightweight data transfer protocol having a hierarchical structure up to one stage, and a method therefor.
[0002]
[Prior art]
In a conventional data transfer system, a protocol passed over a network by a standardized document SOAP (Simple Object Access Protocol 1.1) in a WWW consortium (World Wide Web Consortium) is defined. Have been.
[0003]
For example, as shown in FIG. 14, the conventional data transfer system includes a SOAP client 900 and a SOAP server 800. The SOAP client 900 includes a client application 210, a SOAP client library 910, a client XML (Extensible Markup Language: Extensible Markup Language) serializer 920, a client XML parser 930, and an HTTP client 230. The client XML serializer 920 includes a client structured data interpretation unit 921 and a client XML document creation unit 922. The client XML parser 930 includes a client XML document parsing unit 931, a client XML hierarchy management unit 932, and a client syntax tree creation unit 933.
[0004]
The SOAP server 800 includes an HTTP (Hypertext Transfer Protocol) server 310, a servlet engine 810, a SOAP server servlet 820, an XML serializer 920 and an XML parser 930, a server application management 330, and a server application 340. The server XML serializer 830 includes a server structured data interpretation unit 831 and a server XML document creation unit 832. The server XML parser 840 includes a server XML document parsing unit 841, a server XML hierarchy management unit 842, and a server syntax tree creating unit 843.
[0005]
The conventional data transfer system having such a configuration operates as follows.
[0006]
The client application 210 uses the data of the programming language, and uses the host name and the port number of the HTTP server, the service name corresponding to the server application 340 of the SOAP server 800, the method name activated in the server application 340, and the arguments used for the method activation. The information is sent to the SOAP client library 910. The SOAP client library 910 sends a service name corresponding to the server application 340, a method name activated in the server application 340, and an argument used for method activation to the client structure type data interpretation unit 921 of the client XML serializer 920.
[0007]
The client structured data interpretation unit 921 of the client XML serializer 920 sends the received structured data to the client XML document creating unit 922 while following the data structure in a depth-first manner. The client XML document creation unit 922 converts the received XML document into the XML document with the depth-first structure, and sends the converted XML document to the HTTP client 230. Further, the HTTP client 230 attaches an HTTP header to the received XML document, and sends it to the HTTP server 310 of the SOAP server 800 via the network 500.
[0008]
In the SOAP server 800, the HTTP server 310 looks at the HTTP header, determines that the processing should be performed by the SOAP server servlet 820, and sends the XML document part to the SOAP server servlet 820 running on the servlet engine 810. The SOAP server servlet 820 parses the XML document using the server XML parser 840 and converts it into data in a programming language, and then sends the converted data to the server application management 330.
[0009]
At this time, inside the server XML parser 840, first, the server XML document parsing unit 841 analyzes the XML tag information, and when a start tag for deepening the XML hierarchy appears, the server XML hierarchy management unit 842 performs hierarchy analysis. When the end tag that makes the XML hierarchy shallower appears, the server syntax tree creator 843 performs the structure reduction of the server XML hierarchy management unit 842 by one level while the server syntax tree creation unit 843 Create data of data as data of syntax tree.
[0010]
The server application management 330 finds a server application 340 to be activated from the received syntax tree data of the programming language, activates the server application 340, and obtains an application-level return value. Further, the server application management 330 uses the server XML serializer 830 to convert the obtained return value into an XML document format, and sends it to the SOAP server servlet 820.
[0011]
At this time, in the server XML serializer 830, in particular, the server structure type data interpretation unit 831 sends the received return value to the server XML document creation unit 832 while following the data structure in a depth-first manner. The server XML document creation unit 832 converts the XML document into an XML document while following the depth-first structure, and sends the converted XML document to the SOAP server servlet 820. The SOAP server servlet 820 returns the received XML document to the HTTP server 310. The HTTP server 310 attaches an HTTP header to the returned XML document, and returns it to the HTTP client 230 via the network 500.
[0012]
The HTTP client 230 parses the XML document by the client XML parser 930, converts the document into a data type of a programming language, and returns the data type to the SOAP client library 910.
[0013]
In the client XML parser 930, first, the client XML document parsing unit 931 analyzes the XML tag information, and when a start tag for deepening the XML hierarchy appears, causes the client XML hierarchy management unit 932 to store one level of the hierarchy. On the other hand, when an end tag that makes the XML hierarchy shallower appears, the client syntax tree creation unit 933 reduces the hierarchy of the client XML hierarchy management unit 932 by one level while the client syntax tree creation unit 933 converts the return value data of the programming language into the syntax tree. Create as data.
[0014]
Finally, the SOAP client library 910 converts the return value data in the returned programming language into a type required by the client application 210 and returns it.
[0015]
As a conventional technology for generating a code for linking a client and a server, there is an IDL (Interface Definition Language) compiler.
[0016]
An IDL compiler 1000 shown in FIG. 15 is a conventional technology for generating a code for linking a client and a server. It includes a code creation means 1040. An IDL server 1200 that is a server that cooperates with an IDL client 1100 that is a cooperating client is connected by a network 500.
[0017]
The IDL client 1100 includes an IDL client application 1110, an IDL client library 1120, a client IDL serializer 1130, a client transport library 1140, and a client IDL parser.
[0018]
The IDL server 1200 includes a server transport library 1210, a server IDL parser, an IDL server library 1230, an IDL server application 1240, and a server IDL serializer 1250.
[0019]
The conventional system in which a client and a server having such a configuration cooperate operates as follows.
[0020]
First, the IDL client application 1110 sends, to the IDL client library 1120, argument information necessary for a remote procedure call (Remote Procedure Call) of the IDL server application in the IDL server 1200 in a data type of a programming language, and starts up. Request. The IDL client library 1120 requests the client IDL serializer 1130 to convert the transfer data into a data format that can be transferred on the network 500. The client IDL serializer 1130 converts the transfer data into a format that can be transferred on the network 500, and sends the data to the IDL server side via the network 500 using the client transport library 1140.
[0021]
Next, the server transport library 1210 receives the transfer data from the network 500 and sends it to the server IDL parser 1220. The server IDL parser 1220 converts the received data in a format that can be transferred on the network 500 into argument information of a programming language data type, and sends the converted result to the IDL server library 1230. The IDL server library 1230 uses the argument information received from the server IDL parser 1220 to find the IDL server application 1240 to be started, and sends the found IDL server application 1240 an argument in a data type of a programming language.
[0022]
After receiving the argument from the IDL server library 1230, the IDL server application 1240 executes the application, and returns a return value of the execution result to the IDL server library 1230 in a data type of a programming language. The IDL server library 1230 requests the server IDL serializer 1250 to convert the data type of the programming language returned from the IDL server application 1240 into a format that can be transferred on the network 500. The server IDL serializer 1250 converts the data type of the programming language received from the IDL server library 1230 into a format that can be transferred in the network 500, and sends the data to the IDL client 1100 via the network 500 using the server transport library 1210. .
[0023]
In the IDL client 1100, the client transport library 1140 receives the execution result of the IDL server application 1240 in a data format that can be transferred on the network 500, and sends it to the client IDL parser 1150. The client IDL parser 1150 converts a data format that can be transferred on the network 500 into a data type of a programming language, and sends the data type to the IDL client library 1120. Finally, the IDL client library 1120 returns the return value of the execution result of the IDL server application 1240 which is the data type of the programming language received from the client IDL parser 1150 to the IDL client application 1110.
[0024]
Next, an operation of the IDL compiler 1000 that generates the client IDL serializer 1130 and the client IDL parser 1150 in the IDL client 1100 and the server IDL parser 1220 and the server IDL serializer 1250 in the IDL server 1200 will be described.
[0025]
First, the IDL interpreting means 1010 describes, among interface description languages, a format of the IDL server application 1240 in a format standardized by an object management group called IDL (IDL). Is accepted as input. Next, the IDL interpretation unit 1010 obtains a list of data types used in the input IDL using the IDL data type interpretation unit 1020. Next, the IDL interpreting unit 1010 sends information on the format of the IDL server application 1240 and the data type used therein to the IDL serializing code creating unit 1030 and the IDL parser code creating unit.
[0026]
Next, the IDL serialization code creating unit 1030 generates a client IDL serializer 1130 and a server IDL serializer 1250 from information on the format of the IDL server application 1240 and the data type used therein. Finally, the IDL parser code creation means 1040 generates a client IDL parser 1150 and a server IDL parser 1220 from information on the format of the IDL server application 1240 and the data type used therein.
[0027]
[Problems to be solved by the invention]
The service cooperation system using the conventional data transfer protocol described above has the following problems.
[0028]
The first problem is that when implementing RPC for passing structured data using SOAP, the server side and the client side parse the transferred XML document and convert it into a data type used by the application program. The processing load for conversion is heavy.
[0029]
This is because the server and the client need to parse an XML document having a complicated structure including multiple layers. Specifically, of the two typical parsing methods of XML documents, in a method using a document object model, a tree of a document object model is once created and converted into a data structure for RPC. This is because when Simple API for XML is used, a module for managing a multi-stage hierarchical structure is required by itself.
[0030]
The second problem is that when a system using SOAP is constructed, a large amount of disk space of about 100 megabytes is required on the server side. That is, the storage capacity of a device having no hard disk drive cannot be accommodated, or most of the storage capacity is consumed.
[0031]
The reason is that in a system using a general SOAP, a software of a SOAP server, a Web server such as Apache, a servlet engine such as Tomcat, and a runtime of Java (registered trademark) language are used. This is because an environment is required.
[0032]
A third problem is that it is difficult to serialize the interface description language and easily cooperate between a client having a parsing means and an existing server.
[0033]
The reason is that data conversion between the new protocol and a format that can be interpreted by existing servers is essential.
[0034]
An object of the present invention is to solve such a problem and provide a service linkage that can perform RPC using a format that can be processed at high speed on the server side and the client side and that can represent a structured data type. It is to provide a system.
[0035]
Another object of the present invention is to provide a service cooperation system in which a server function for interpreting a text-based protocol independent of an OS or a programming language is accommodated in a small disk area of a device having no HDD (hard disk drive). is there.
[0036]
Still another object of the present invention is to provide a service cooperation system that achieves the above two objects and allows a client to access an existing server.
[0037]
[Means for Solving the Problems]
Therefore, the present invention aims to solve the above-mentioned problems, and to reduce the processing load of a remote method call for transferring structured data and to reduce the storage capacity in the construction of a system for performing this XML parsing. Provided is a service cooperation system that can use a lightweight data transfer protocol that can access an existing server.
[0038]
The service cooperation system using the lightweight data transfer protocol according to the first embodiment of the present invention includes a client non-recursive data expression generation serializer (230), a server non-recursive data expression interpretation parser (320), and a server non-recursive data expression. It includes a generation serializer (350) and a client non-recursive data expression interpretation parser (250), can process RPC activation of the server application (340) from the client application (210) at high speed, and the server (300) uses the HDD It can be reduced to a size that can fit in devices that do not have it.
[0039]
That is, the client non-recursive data expression generation serializer (230) includes a client structured type array information table creating means (232) for creating a structured type data argument of RPC using a stack structure for structured type data and array structure information. By using the ID pointer, the data is converted into a text format with at most one layer. The server non-recursive data expression interpretation parser (320) links at most one level of hierarchical and structured data when converting text format data transferred via the network (500) into a format interpretable by a programming language. A server parameter information creating means (324) having a function of assembling the structure of parameter information with a server ID pointer table (323) for managing the relationship is included.
[0040]
The server non-recursive data expression generation serializer (350) uses a stack structure for the structure type data and the structure information of the array to create a return value that starts the server application (340). ) And convert it to a text format with at most one level of hierarchy.
[0041]
The client non-recursive data expression interpretation parser (250), when returning a return value converted into a text format by the server non-recursive data expression generation serializer (350) to a return value of a programming language, at most one level of hierarchical and structured data And a client parameter information creating means (254) having a function of assembling the structure of parameter information.
[0042]
Also, in the service cooperation system using the lightweight data transfer protocol according to the second embodiment of the present invention, an interface description language compiler ( 100) is added, and the server application (340) in the server (300) and the SOAP server (500) can be started by the RPC from the client application (210) in the client (200). Therefore, from the description in the interface description language, the client non-recursive data expression generation serializer (230) and the client non-recursive data expression interpretation parser (250) in the client (200), and the server non-recursive data expression in the server (300) Each unit of the interpretation parser (320) and the server non-recursive data expression generation serializer (350) is operated.
[0043]
Also, in the service cooperation system using the lightweight data transfer protocol according to the second embodiment of the present invention, an interface description language compiler ( 100) is added, and the existing server (710) is started by the RPC from the client application (210) in the client (200) via the server application (340) in the server (300) and the protocol converter (400). It is possible.
[0044]
Therefore, the interface description language compiler (100) converts the description in the interface description language into a client non-recursive data expression generation serializer (230), a client non-recursive data expression interpretation parser (250), and a server ( In 300), a server non-recursive data expression interpretation parser (320) and a server non-recursive data expression generation serializer (350) are generated, and in a protocol converter (400), respective means of a protocol conversion module (410) are generated.
[0045]
BEST MODE FOR CARRYING OUT THE INVENTION
Next, embodiments of the present invention will be described in detail with reference to the drawings.
[0046]
First, a first embodiment of the present invention will be described with reference to FIG.
[0047]
As illustrated, the first embodiment includes a client 200 of RPC (Remote Procedure Call), a server 300 of RPC, and a network 500 that can transfer data between the client 200 and the server 300. I have.
[0048]
The client 200 includes a client application 210, a client non-recursive data expression library 220, a client non-recursive data expression generation serializer 230, an HTTP client 240, and a client non-recursive data expression interpretation parser 250. The client non-recursive data expression generation serializer 230 includes a client serializer 231, a client structured type array information table 232, and a client non-recursive data expression document creation unit 233. The client non-recursive data expression interpretation parser 250 includes a client parse unit 251, a client header information storage unit 252, a client ID pointer table 253, a client parameter information storage unit 254, and a programming language return value creation unit 255.
[0049]
The server 300 includes an HTTP client 310, a server non-recursive data expression interpretation parser 320, a server application management 330, a server application 340, and a server non-recursive data expression generation serializer 350. The server non-recursive data expression interpretation parser 320 includes a server parse unit 321, a server header information storage unit 322, a server ID pointer table 323, a server parameter information storage unit 324, and a server application startup information creation unit 325. The server non-recursive data expression generation serializer 350 includes a server serializer 351, a server structure type array information table 352, and a server non-recursive data expression document creation unit 353.
[0050]
The arrows in FIG. 1 represent the flow of data. The components of FIG. 1 operate roughly as follows.
[0051]
The client application 210 is a part created by a user of the system of the present invention, and performs a method call in a normal programming language such as “Java (registered trademark), C, C ++”. The client non-recursive data representation library 220 receives a method call in a programming language from the client application 210, sends the received data to the client non-recursive data representation generation serializer 230, and returns a return value from the client non-recursive data representation interpretation parser 250. The information is obtained and returned to the client application 210.
[0052]
The client non-recursive data expression generation serializer 230 converts the received data into a lightweight data protocol based on text and sends it to the HTTP client 240. Inside the client non-recursive data expression generation serializer 230, the client serializer 231 first receives data in a programming language, and if the data is simple type data having no structure, the client non-recursive data expression document creation means 233 In the case of structured data or array data, the data is sent to the client structure type array information table 232.
[0053]
The client structure type array information table 232 is sent to the client non-recursive data expression document creating means 233 in the order given from the client serialization 231 first. As a result, the child element portion of the structured data is sent to the client non-recursive data expression document creating means 233 before the parent element. The client non-recursive data expression document creation means 233 first receives the information received from the client structured type array information table 232 in the order in which it was sent to itself, and then receives the information received from the client serialization unit 231 in the order in which it was sent to itself. The serialized text document is sent to the HTTP client 240 in the format of the lightweight data expression protocol.
[0054]
The HTTP client 240 adds an HTTP header to the character string of the text expression expressed by the lightweight data expression protocol from the client non-recursive data expression generation serializer 230, and sends the character string to the server 300 via the network 500. As a result, the HTTP client 240 obtains an HTTP header-equipped lightweight data transfer protocol format representing the return value of the RPC, and returns this lightweight data transfer protocol portion to the client non-recursive data expression interpretation parser 250.
[0055]
The client non-recursive data expression interpretation parser 250 converts the lightweight data transfer protocol based on the text returned from the HTTP client 240 into a data type of a programming language, and then returns it to the client non-recursive data expression library 220. In the client non-recursive data expression interpretation parser 250, first, the client parse unit 251 receives the data in the lightweight data transfer protocol format, and sends the header part of the lightweight data transfer protocol to the client header information storage unit 252. Next, the client parsing unit 251 sends the body part of the lightweight data transfer protocol to the client parameter information storage unit 254 while temporarily storing the body part in the client ID pointer table 253. The programming language return value creation unit 255 reads the data stored in the client header information storage unit 252 and the client parameter information storage unit 254, creates return value information, and sends it back to the client non-recursive data expression library 220.
[0056]
The HTTP server 310 receives the data in the lightweight data transfer protocol format with the HTTP header via the network 500, and checks the HTTP header. After confirming that the data is of the lightweight data transfer protocol by checking, the HTTP server 310 sends the lightweight data transfer protocol part to the server non-recursive data expression interpretation parser 320.
[0057]
In the server non-recursive data expression interpretation parser 320, the server parse unit 321 receives the lightweight data transfer protocol part from the HTTP server 310 and sends the header part of the lightweight data transfer protocol part to the server header information storage unit 322. On the other hand, the body part is stored in the server parameter information storage unit 324 using the server ID pointer table 323. The server application start information creation unit 325 reads data from the server header information storage unit 322 and the server parameter information storage unit 324, converts the data into a data type of a programming language, and sends the converted data type to the server application management 330. .
[0058]
The server application management 330 manages the correspondence between the name of the server application and the corresponding server application 340, and includes the name of the server application 340 among the data types in the programming language passed from the server non-recursive data expression interpretation parser 320. Extract the part corresponding to. The server application management 330 sends an argument expressed in the programming language for the method expressed in the data type in the programming language to the server application 340 corresponding to the extracted name. The server application management 330 sends the argument, activates the server application 340, and obtains a return value from the server application 340. Further, the server application management 330 sends the return value received from the server application 340 to the server non-recursive data expression generation serializer 350 in the form of a data type of a programming language.
[0059]
The server application 340 receives the method call from the server application management 330 and returns a return value to the server application management 330.
[0060]
The server non-recursive data expression generation serializer 350 sends the data type of the programming language returned from the server application management 330 to the client non-recursive data expression document creating means 353 in the case of simple type data having no structure. In the case of structured data or array data, it is sent to the client structure type array information table 352. The client structure type array information table 352 is sent to the client non-recursive data expression document creation unit 353 in the order received from the client serialization 231 first. The client non-recursive data representation document creation means 353 first receives the data received from the server structure type array information table 352 in the order in which it was transmitted to itself, and then receives the data received from the server serialization unit 351 in the order in which it was transmitted to itself. It is serialized and returned to the HTTP server 310 in the form of a lightweight document representation protocol that is a text document.
[0061]
The network 500 is a network that uses TCP / IP, which is a standard protocol of the Internet, for example.
[0062]
Next, the overall operation in the first embodiment will be described in detail with reference to the block diagram of FIG. 1 and the sequence diagram of FIG. Although the step number numbers shown in FIG. 2 are written in circles, in the following description, only the number numbers will be omitted.
[0063]
First, the client application 210 uses the data type of the programming language, and uses the host name and port number of the HTTP server, the service name corresponding to the server application 340, the name of the method to be started in the server application 340, The argument information to be passed is sent to the client non-recursive data expression interpretation parser serializer 220 (step A-1). In this case, the header information includes the service name and the method name. Next, the client non-recursive data representation library 220 sends the header information and the argument information to the client non-recursive data representation generation serializer 230 (step A-2), and obtains data by the lightweight data transfer protocol as the answer (step A-2). Step A-3) is performed.
[0064]
Next, the client non-recursive data expression library 220 sends the host name and port number received in step A-1 and the data according to the lightweight data transfer protocol obtained in step A-3 to the HTTP client 240 (step A). -4). The HTTP client 240 adds an HTTP header before the lightweight data transfer protocol received in step A-4, and sends it to the HTTP server 310 via the network 500 (step A-5).
[0065]
The HTTP server 310 checks the HTTP header portion and checks that the transmitted data is in the format of the lightweight data transfer protocol, and then sends the lightweight data expression protocol portion to the server non-recursive data expression interpretation parser 320 (step A-6).
[0066]
The server non-recursive data expression interpretation parser 320 interprets the lightweight data transfer protocol part and extracts header information and argument information in a data format in a programming language (step A-7). Further, the server non-recursive data expression interpretation parser 320 sends the service name corresponding to the server application 340 extracted from the header information, the method name activated in the server application 340, and the argument information to the server application management 330 (step A-). 8) Yes.
[0067]
The server application management 330 specifies the server application 340 to be started from the service name passed in step A-8, sends the argument information received in step A-8 to the server application 340, and executes step A-8. (Step A-9).
[0068]
The server application 340 performs processing using the argument received in step A-9, and returns a return value of the processing result to the server application management 330 (step A-10). The server application management 330 adds return type information, for example, a character string type or a numeric type, to the return value received in step A-10, and sends the return value to the server non-recursive data expression generation serializer 350 (step A-11). ).
[0069]
The server non-recursive data expression generation serializer 350 converts the return value information received in step A-11 into a lightweight data transfer protocol (step A-12). Further, the server non-recursive data expression generation serializer 350 sends the lightweight data transfer protocol created in step A-12 to the HTTP server 310 (step A-13). The HTTP server 310 attaches an HTTP header before the lightweight data transfer protocol received in step A-13, and sends the HTTP header to the HTTP client 240 via the network 500 (step A-14).
[0070]
The HTTP client 240 checks the HTTP header and checks that the transmitted data is in the format of the lightweight data transfer protocol, and then transmits the lightweight data representation protocol to the client non-recursive data representation interpretation parser 250 (step A). -15). Further, the client non-recursive data expression interpretation parser 250 interprets (parses) the lightweight data transfer protocol part and extracts return value information in a data format in a programming language (step A-16). Further, the client non-recursive data expression interpretation parser 250 sends the return value in the programming language extracted in step A-16 to the client non-recursive data expression library 220 (step A-17).
[0071]
Finally, the client non-recursive data expression library 220 returns the return value obtained in step A-17 to the client application 210 (step A-18).
[0072]
Next, the conversion method between the data type of the programming language and the lightweight data expression protocol will be described in detail with reference to FIGS.
[0073]
First, referring mainly to FIG. 3, in the client non-recursive data expression generation serializer 220 and its components, a portion for creating data of the lightweight data transfer protocol from the header information and the argument information, that is, step A in FIG. -2 and step A-3 will be described in detail.
[0074]
As an argument of the method provided by the server application 340, for example, a return value is represented by basic type data (PrimitiveA) as a format of the method of the server application shown in 1) of FIG. As shown in the figure, any one of the basic type data (Primitive_Barg1), the structural type data (Struct_Carg2), and the one-dimensional array of the basic type data (PrimitiveArray_Darg3) is represented by an arbitrary number of methods. May be. In particular, as the basic type data, an integer value type, a character string type, a boolean value type, a time type, and a byte string type encoded in base64 can be used.
[0075]
Structured data can be used as a component of structured data as shown in 2) of FIG. As the return value of the server application 340, one-dimensional array of basic type data, structural type data, or basic type data can be used.
[0076]
First, the client serializer 231 in the client non-recursive data expression generation serializer 230 stores header information including a service name and a method name and argument information (Primitive_Barg1, Struct_C) in order to start a server application in the format of FIG. arg2, PrimitiveArray_Darg3) are sent. The client serializing unit 231 sends the header information including the service name and the method name to the client non-recursive data expression document creation unit 233. The client non-recursive data expression document creating means 233 creates a header portion by the lightweight data expression protocol from the received header information including the service name and the method name.
[0077]
Specifically, “Head” to “blank line” shown in FIG. 6 are created. “Head” is a reserved word indicating the beginning of a header. “SN” is a reserved word, followed by a service name representing the name of the server application 340. For example, in FIG. 6, the service name is “Server APPlication”. “PN” is a reserved word, and the method name of the server application 340 to be started thereafter appears. For example, in FIG. 6, a method “method1” is activated.
[0078]
Next, a method of interpreting argument information in the client serializing unit 231 will be described with reference to the flowchart of FIG.
[0079]
First, the client serializer 231 extracts one piece of argument information (step B1), and determines whether the extracted argument information is basic type data (step B2). If the result determined in step B2 is "NO" and the data is not basic type data, it is determined whether or not the data is array type (step B3). If step B3 is "No" and is not an array type, the data is always structured type data, but it is determined whether or not the data is structural type data (step B4). If the result of step B4 is "yes" and the data is structured data, an ID pointer indicating the hierarchy is assigned to the structured data, and the argument name assigned with the ID pointer is transmitted to the client non-recursive data expression document creating means 233. It is sent (step B5).
[0080]
Next, the client serializing unit 231 sends a pair of the structured data name and the ID pointer value assigned in step B5 to the client structured array information table creating means 232 (step B6). Next, one child element of the structured data is extracted (step B7), and it is determined whether the child element of the structured data extracted in step B7 has structured data or an array (step B8). You.
[0081]
If step B8 is "NO" and neither array nor structure type data is provided as a child element of the structure type data, the child element of the structure type data is sent to the client structure type array information table creating means 232 (step B9). Next, the client serializing unit 231 determines whether there is a child element next to the child element extracted in step B7 (step B10).
[0082]
If step B10 is "yes" and there is a next child element, the step B7 is executed. If it is determined in step B8 that the array has the array or the structured data as a child element of the structured data, the ID pointer indicating the array for the structured data or the array is changed to the client structured array of the allocation destination. The information is sent to the information table creation means 232 (step B11). Thereafter, the process returns to step B6, and the structured data and the set of assigned ID pointers are sent to the structured array information table creating means 232.
[0083]
If the above step B2 is "Yes" and it is determined that the data is basic type data, the client serializing unit 231 sends the argument name and the argument value to the client non-recursive data expression document creating means 233 (step B12).
[0084]
If it is determined in step B3 that the type is an array type, the client serializing unit 231 allocates an ID pointer indicating a hierarchy to the array type and sends it to the client non-recursive data expression document creation unit 233. (Step B13). Next, the array type component is sent to the client array information table creating means 232 (step B14).
[0085]
Next, it is determined whether the step B10 is "No" or following the step B12 or B14, and it is determined whether there is a next argument (step B15). If "Yes" with an argument, the process returns to the step B1. If "no" without an argument, the process shown in the flowchart of FIG.
[0086]
When the client serialization unit 231 completes the processing shown in the flowchart of FIG. 4 described above with the data of FIG. 3 as input, the client non-recursive data expression document creation unit 233 and the client structured type array information table creation unit 232 are stored in memory. 5 has data having a stack structure shown in FIG. After the processing in FIG. 4, the data held by the client structural type array creating unit 232 is sent to the client non-recursive data expression document creating unit 233.
[0087]
The client non-recursive data expression document creating unit 233 traces the data received from the client structured type array information table creating unit 232 from the top of the stack, for example, from “10.” in the case of FIG. Create a text document. First, a reserved word "Body" is output as shown in FIG. Also, looking at the stack of “10.”, it is determined from the keyword “Array” that the array is an array. Then, when the user goes down the stack, “id = 200 Primitive_Array_D” is found at the location of “7.”, so it is determined that the array is the one so far, and the sixth row in FIG. To the tenth line are output.
[0088]
Next, since “Primitive_H value_of_H” of the basic type data can be found at “6.” in FIG. 5, the element of “Struct_F of id = 110” shown in “4. Is recognized. As a result, lines 11 to 14 in FIG. 6 are output according to the format of the structured data. Next, it is confirmed that “Struct_F” is defined as “id = 110” in “3.” in FIG. 5, and further, “2.” is replaced with “id = 110” defined in “1.”. Since it is determined that the element is “100”, the 15th to 18th lines in FIG. 6 are output in the form of structured data.
[0089]
After completing the transmission of the data received from the client structured array information table generating means 232, the client non-recursive data representation document generating means 233 stores the information on the memory received from the client serializing section 231 under the stack, that is, in the form of a numeral. In the order from the smallest, the 19th to 21st lines in FIG. 6 are output. Then, after describing the blank line, the client non-recursive data expression document creating means 233 describes “End” indicating the end of the lightweight data transfer protocol, and completes the output.
[0090]
Next, referring to the flowchart of FIG. 7 and the example of the lightweight data transfer protocol of FIG. 6, the server non-recursive data expression interpretation parser 320 creates header information and argument information from the lightweight data transfer protocol, The procedure of Step A-7 shown in FIG. 2 up to sending to the management 330 will be described in detail.
[0091]
First, the server parsing unit 321 reads a line from “Head” indicating the beginning of the lightweight data transfer protocol to a blank line in FIG. 6, and, for example, sets a header name “sN” and a header value such as “serverApplication” as a set. Then, it is stored in the server header information creating means 322 (step C1). Next, in the lightweight data transfer protocol, a line in which "Body" representing the beginning of the argument portion is described is read (step C2). Next, the next line is read by one (step C3). It is determined whether the line read in step C3 is a line that is an ID pointer to be expressed in the form of “id = number” (step C4). In the case of a line starting from the ID pointer, up to "@" which is a unit of the structure represented by the ID pointer is read (step C5), and then the ID pointer value is included in the line read in step C5. It is checked whether or not it is present (step C6).
[0092]
Referring to FIG. 6, an example of “Structure_F: id = 110” on the 17th line corresponds to a case where an ID pointer value is included. If the result of step C6 is "No" and it is determined that the ID pointer value is not included, the server parse unit 321 creates an entity in the programming language of the structured data or array from the data read in step C5. Then, it sends it to the server parameter information creating means 324 (step C7). For example, when the sixth to tenth lines in FIG. 6 are read, an entity in the programming language of the array is created, and when the eleventh to fourteenth lines in FIG. An entity of data is created. The pair of the reference to the entity created in step C7 and the ID pointer value is registered in the server ID pointer table 323 (step C8).
[0093]
On the other hand, if the row read “yes” in step C6 contains an ID pointer value, the server parse unit 321 uses the ID pointer value as a key to point to the ID from the server ID pointer table 323 using the ID pointer. Then, an entity in a programming language is acquired using the reference (step C9). Next, an entity is created from the portion read in step C5, and the entity obtained in step C9 is embedded in the portion represented by the ID pointer (step C10). For example, lines 15 to 18 in FIG. 6 start with an ID pointer. However, after the entity of this part is created, the part of “id = 110” indicated on the 17th line includes the structured type data created from the 11th to 14th lines in FIG. Is embedded.
[0094]
When the above step C4 is "No" and it is determined that the line does not start from the ID pointer, the server parse unit 321 determines whether or not the line represents basic type data (step C11). If this step C11 is "yes" and it is determined that the line represents the basic type data, the 19th line in FIG. 6 corresponds to this example. The data of the basic type data is created in a programming language, and the server parameter information is created. It is sent to the creating means 324 (step C12).
[0095]
When it is determined that the above-mentioned step C11 is “No” and the row does not represent the basic type data, it is confirmed that the row corresponds to the structural type data or the array (step C13). For example, the 20th line in FIG. 6 corresponds to the structured data, and the 21st line corresponds to the array.
[0096]
Next, an ID pointer value portion is obtained from the read line (step C14). Next, after the reference pointed to by the server ID pointer is obtained using the ID pointer as a key, the entity is obtained (step C15). Next, the programming language entity acquired in step C15, that is, the structure type data or the array of the programming language is embedded in the ID pointer portion to construct the programming language entity (step C16). For example, in FIG. 6, the structural type data created from the 15th line to the 18th line is embedded in the portion of “id = 100” in the 20th line, and the 17th line portion is further embedded in the “id = 100” portion. The first line is embedded.
[0097]
Subsequent to steps C8, C10, and C16, the server parse unit 321 reads the next line (step C17). It is determined whether the line read in step C17 is an empty line (step C18). If it is determined in step C18 that the result is "No" and the line is not blank, the next procedure returns to step C3. If it is determined in step C18 that the line is blank, the next line is read, and a character string "End" indicating the end of the lightweight data transfer protocol is confirmed (step C19).
[0098]
After the series of processing flows shown in FIG. 7 is completed, the server application activation information creating unit 325 reads out the service name, the method name, and the argument information from the server header information creating unit 322 and the server parameter information creating unit 324, and It is sent to the application management 330.
[0099]
Next, the procedure in which the server non-recursive data expression generation serializer 350 creates the lightweight data transfer protocol transmitted in step A-11 in FIG. 2 from the return value information will be described in detail with reference to the flowchart in FIG.
[0100]
First, the return value information is sent from the server application management 330 to the server serializer 351 in the server non-recursive data expression generation serializer 350. When the server application starts normally, the server serialization unit 351 sends the success of the normal startup to the server non-recursive data expression document creation unit 353. The server non-recursive data expression document creation means 353 creates a header portion based on the lightweight data expression protocol indicating that the server application has been successfully started. Specifically, from “Head” in FIG. 10 to blank lines are created. This “Head” is a reserved word indicating the beginning of the header of the lightweight data representation protocol. In addition, “rPro” in FIG. 11 is a reserved word, followed by a character string “normal” if the activation of the server application 340 is normal, and a character string “Error” otherwise.
[0101]
Here, the server serializer 351 extracts return value information (step D1). Next, the server serializer 351 determines whether the return value extracted in step D1 is basic type data (step D2). If the result determined in step D2 is "No" and the data is not basic type data, it is determined whether or not the data is array type (step D3). If the step D3 is "NO" and is not an array type, it is always structured type data, so it is confirmed that the data is structured type data (step D4). If the data is structured type data, an ID pointer indicating a hierarchy is assigned to the structured type data, and the return value assigned the ID pointer is sent to the server non-recursive data expression document creating means 353 (step D5).
[0102]
Next, the server serializing unit 351 sends information, which is a combination of the structured data name and the ID pointer value allocated in step D5, to the server structured data array information creating means 352 (step D6). One child element is extracted (step D7). It is determined whether or not there is further structural type data or an array as a child element of the structural type data extracted in step D7 (step D8).
[0103]
If the result of step D8 is “No”, and if neither the array nor the structured data is included as the child element of the structured data, the server serializing unit 351 sends the child element of the structured data to the server structured array information table creating means 352 ( Step D9) and then determine whether there is a child element next to the child element extracted in step D7 (step D10). If this step D10 is "yes" and there is a next child element, the procedure of step D7 is executed.
[0104]
If the step D8 determines "Yes" that the structure serial data has an array or structured data as a child element, the server serializing unit 351 allocates an ID pointer representing the array to the structured data or the array, and The data is sent to the structured type array information table creating means 352 (step D11), and then a set of the structured type data and the assigned ID pointer is sent to the structured type data array information creating means 352 (step D11).
[0105]
If the above-mentioned step D2 is "Yes" and the data is determined to be the basic type data, the server serializing unit 351 sends the argument name and the argument value to the client non-recursive data expression document creating means 233 (step D12). When it is determined in step D3 that the type is an array type, the server serializing unit 351 allocates an ID pointer indicating a hierarchy to the array type and sends it to the server non-recursive data expression document creating unit 353 (step S3). D13), and then send the array type component to the server array information table creating means 352 (step D14).
[0106]
The process of the flowchart shown in FIG. 8 ends with “No” in step D10 and steps D12 and D14. After the processing shown in FIG. 8, the data held by the server structured type array creating unit 352 is sent to the server non-recursive data expression document creating unit 353.
[0107]
Next, the server non-recursive data representation document creating means first outputs “Body”, and then traces the data received from the server structure type array information table creating means 352 from the top of the stack, while using the lightweight data transfer protocol format. Create a text document. After completing the transmission of the data received from the client structured type array information table generating unit 352, the server non-recursive data representation document generating unit 353 transmits the information on the memory received from the client serializing unit 231 following the stack. . In this way, the server non-recursive data representation document creating means 353 describes "End" indicating the end of the lightweight data transfer protocol after describing the blank line, and completes the transmission.
[0108]
Next, the procedure in which the client non-recursive data expression interpretation parser 250 creates header information and return value information from the lightweight data transfer protocol in step A-16 in FIG. 2 will be described in detail with reference to the flowchart of FIG. I do.
[0109]
First, in the client non-recursive data expression interpretation parser 250, the client parse unit 251 reads line by line from “Head” representing the beginning of the lightweight data transfer protocol to blank lines, and reads the header name, for example, “rPro” in FIG. And a header value, for example, "normal" in FIG. 11, are stored as a set in the client information creating means 252 (step E1). Next, in the lightweight data transfer protocol, a line describing "Body" indicating the beginning of the argument portion is read (step E2), and then the next line is read (step E3).
[0110]
Next, the client parse unit 251 determines whether or not the line read in step E3 is a line that is an ID pointer to be expressed in the form of “id = number” (step E4). If the step E4 is "Yes" and the line starts from the ID pointer, the data up to "@" which is a unit of the structure represented by the ID pointer is read (step E5). Next, it is checked whether or not the ID pointer value is included in the line read in step E5 (step E6).
[0111]
If this step E6 is "No" and it is determined that the ID pointer value is not included, the client parse unit 251 creates an entity in a structured language or an array programming language from the data read in step E5, It is sent to the client parameter information creation means 254 (step E7). Next, a pair of the reference to the entity created in step E7 and the ID pointer value is registered in the client ID pointer table 253 (step E8).
[0112]
If step E6 is “Yes” and the read line contains an ID pointer value, the client parse unit 251 is pointed to by the ID pointer from the client ID pointer table 253 using the ID pointer value as a key. A reference is obtained, and an entity in a programming language is obtained using the reference (step E9). Next, the client parse unit 251 creates an entity from the portion read in step E5, and embeds the entity acquired in step E9 in the portion indicated by the ID pointer (step E10).
[0113]
If step E4 is "No" and it is determined that the line does not start from the ID pointer, the client parse unit 251 subsequently determines whether or not the line represents basic type data (step E11). If this step E11 is "Yes" and it is determined that the line represents the basic type data, the data of the basic type data is created in a programming language and sent to the client parameter information creating means 254 (step E12).
[0114]
When it is determined that the step E11 is “No” and the row does not represent the basic type data, the client parse unit 251 confirms that the row corresponds to the structural type data or the array (step E13). The ID pointer value is obtained from the read line (step E14). Next, after the reference pointed to by the server ID pointer is obtained using the ID pointer as a key, the entity is obtained (step E15). Next, the structure type data or array, which is the entity of the programming language acquired in the step E15, is embedded in the ID pointer portion to construct the programming language entity (step E16).
[0115]
Subsequent to the steps E8, E10, E12 and E16, the client parse unit 251 reads the next line (step E17).
[0116]
Next, the client parse unit 251 determines whether the line read in step E17 is a blank line (step E18). If it is determined that this step E18 is “NO” and that the line is not blank, the procedure returns to the step E3. If it is determined in step E18 that the line is blank, the next line is read and the character string "End" indicating the end of the lightweight data transfer protocol is confirmed (step E19). A series of processing flow shown ends.
[0117]
After the step E19, the programming language return value creation unit 255 reads data from the client header information creation unit 252 and the client parameter information creation unit 254, and sends the return value portion to the client non-recursive data expression library 220.
[0118]
In the above-described first embodiment, even when the structured data is expressed, the text document transmitted and received between the client and the server includes at most one level of hierarchy, and therefore includes multiple levels of hierarchy. Compared to the case where the class representing the complexity of the grammar is a context-free grammar in the case, it can be expressed by a regular grammar that can be interpreted faster. Therefore, the parsing can be performed at high speed. In addition, since it is possible to assume that the hierarchical structure has at most one level, it is possible to create the parsing program itself smaller than an XML parser that allows multiple levels.
[0119]
Next, an operation corresponding to FIG. 2 in the above-described first embodiment will be described using a specific example with reference to FIGS.
[0120]
FIG. 5 shows a lightweight data transfer protocol portion of data sent from the client to the server when registering data in the address book. An HTTP header is added to the actual transmission data. FIG. 6 shows a lightweight data transfer protocol portion returned from the server to the client.
[0121]
First, in the above-described step A-1, the client application 210 uses the data type of the programming language, and uses the host name and port number of the HTTP server, the service name corresponding to the server application 340, and the method name to be started in the server application 340. , And argument information to be passed when this method is activated, are sent to the client non-recursive data expression library 220. That is, in the illustrated example, the host name of the HTTP server is “distri.nwk.cl.nec.co.jp”, the port number is “80” used for HTTP, and the service corresponding to the server application 340 is provided. The name is “Addressbook”, and the method name activated in the server application 340 is “register”. These are included in the header information. Further, a structure having character string type data “Yasuyuki_BEPPU” represented by “sT” as argument information to be passed when this method is activated, and “block, town, city, preference, country, zipCode” as constituent elements. There are three types: body and character string type “04485600000”.
[0122]
In the next step A-2, the client non-recursive data representation library 220 converts the service name and the method name included in the header information and the following argument information among those received from the client application 210 into the client non-recursive data representation generation serializer. Send to 220. The service name is “Addressbook” corresponding to the server application 340, and the method name is “register” to be started in the server application 340. The argument information passed when this method is activated is a structure having character string type data “Yasuyuki_BEPPU” represented by “sT” and “block, town, city, preference, country, zipCode” as constituent elements. And a character string type “04485600000”.
[0123]
In the next step A-3, the client non-recursive data expression generation serializer 230 sets “Addressbook” as the service name in the data of the programming language received in step A-2 described above as the method name to be started in the server application 340. The “register” is further returned to the client non-recursive data expression library 220 with the lightweight data expression protocol created as argument information. The argument information has, as constituent elements, character string type data “Yasuyuki_BEPPU” represented by “sT” and “block, town, city, preference, country, zipCode” to be transmitted when this method is activated. From the structure and the character string type “04485600000”, a lightweight data expression protocol that is a part from “Head” to “End” shown in FIG. 5 is created.
[0124]
In the next step A-4, the client non-recursive data expression library 220 stores the host name “distri.nwk.cl.nec.co.jp” and the port number “80” received in step A-1 above, and The data according to the lightweight data transfer protocol received in step A-3 is sent to the HTTP client 240.
[0125]
In the next step A-5, before the lightweight data transfer protocol received in the step A-4, the HTTP client 240 checks the HTTP header from “POST” to “Content-length: xxx” shown in FIG. And a blank line, and send the result to the HTTP server 310 via the network 500.
[0126]
In the next step A-6, the HTTP server 310 looks at the “Content-type text / cdr” portion of the HTTP header and checks that the transmitted data is in the format of the lightweight data transfer protocol. The expression protocol part is sent to the server non-recursive data expression interpretation parser 320.
[0127]
In the next step A-7, the server non-recursive data expression interpretation parser 320 interprets the lightweight data transfer protocol part, and uses “Addressbook” as a service name corresponding to the server application 340 based on the header information and a method started in the server application 340. A character string type data "Yasuyuki_BEPPU" represented by "sT" from the argument information and "block, town, city, preference, country, zipCode" as structural elements are extracted from the argument information. , And “04485600000” which is a character string type.
[0128]
In the next step A-8, the server non-recursive data expression interpretation parser 320 sends the service name “Addressbook” corresponding to the server application 340 extracted from the header information, the method name “register” to be started in the server application 340, and the argument The information is sent to the server application management 330.
[0129]
In the next step A-9, the server application management 330 specifies the server application 340 to be activated from the service name “Addressbook” received in step A-8, and receives the server application 340 in step A-8. Then, the method receives the argument information and activates the method received in step A-8.
[0130]
The argument information includes character string type data “Yasuyuki_BEPPU”, a structure having “block, town, city, preference, country, ZipCode” as constituent elements, and “04485600000” in a character string type.
[0131]
In the next step A-10, the server application 340 performs processing using the argument received in step A-9, and returns a return value of the processing result to the server application management 330. Next, in step A-11, the server application management 330 sends “return value information” obtained by adding a true / false type, which is type information, to the return value received in step A-10, to the server non-recursive data expression generation serializer 350. I do.
[0132]
Next, in step A-12, the server non-recursive data expression generation serializer 350 converts the return value information received in step A-11 into the lightweight data transfer protocol shown in FIG. For example, the content of the lightweight data transfer protocol shown in FIG. 6 includes a reserved word indicating whether or not the method call “rPro” was normally performed from “Head”, which is the header part of the lightweight data representation protocol, to a blank line. "Normal" shown in FIG. 6 indicating that the operation has been normally performed is included. Similarly, the body part of the lightweight data expression protocol from “Body” to a blank line contains boolean value data “true” indicating that registration in the address book was successful.
[0133]
Next, in step A-13, the server non-recursive data expression generation serializer 350 returns the lightweight data transfer protocol created in step A-12 to the HTTP server 310. In the next step A-14, the HTTP server 310 adds an HTTP header before the lightweight data transfer protocol returned in step A-13 and sends it to the HTTP client 230 via the network 500.
[0134]
In the next step A-15, the HTTP client 230 looks at the HTTP header part and checks that the transmitted data is in the format of the lightweight data transfer protocol. The part is sent to the client non-recursive data expression interpretation parser 250. Next, in step A-16, the client non-recursive data expression interpretation parser 250 interprets the lightweight data transfer protocol part shown in FIG. 6 and extracts a boolean value “true” of return value information in a data format in a programming language. .
[0135]
Next, in step A-17, the client non-recursive data expression interpretation parser 250 returns the return value information extracted in step A-16 to the client non-recursive data expression library 220. In the last step A-18, the client non-recursive data representation library 220 returns "true" representing the return value information received in step A-17 to the client application 210.
[0136]
Next, a second embodiment of the present invention will be described in detail with reference to FIGS. FIG. 13 is an interface description using WSDL (Web Service Description Language).
[0137]
The difference between the second embodiment shown in FIG. 12 and the first embodiment shown in FIG. 1 is that the following is added in the configuration.
[0138]
The added configuration is the interface description language compiler 100, the protocol converter 400, the client-protocol converter network 600, the protocol converter-existing server network 700, and the existing server 710.
[0139]
The interface description language compiler 100 includes an interface description language interpretation unit 110, a data type correspondence definition unit 120, a serialized code creation unit 130, a conversion program creation unit 140, and a parser code creation unit 150. The protocol converter 400 includes a protocol conversion module 410 and an HTTP client / server 420.
[0140]
These components generally have the following functions.
[0141]
The interface description language interpreting means 110 receives an input by an interface description as shown in FIG. 13, reads the interface description language, and cuts out a data type expression part. The data type correspondence definition unit 120 receives the expression part of the data type from the interface description language interpretation unit, and returns the data type of the corresponding programming language.
[0142]
The serialization code creation unit 130 receives a list of data types used in the interface description language from the interface description language interpretation unit 110, and sends a code for serializing those data types to the client non-recursive data expression generation serializer 230. A recursive data expression generation serializer is output to the server non-recursive data expression generation serializer 350 as a server non-recursive data expression generation serializer.
[0143]
At the time of this output, the serialization code creation means 130 outputs only the serialization code of the data type of the argument required for the serialization on the client side as a client non-recursive data expression generation serializer, and the data of the return value required for the server side serialization Outputs the code that serializes the type as a server non-recursive data representation generation serializer.
[0144]
The conversion program creating means 140 receives a list of data types used in the interface description language from the interface description language interpreting means 110, and converts between the data types used in the client 200 and the formats used in the existing server 710. The program is output to the protocol conversion module 410 as a protocol conversion module.
[0145]
The parser code creating means 150 receives a list of data types used in the interface description language from the interface description language interpreting means 110 and sends a code for parsing those data types to the client non-recursive data expression interpretation parser 250. It outputs to the server non-recursive data expression interpretation parser 320 as a recursive data expression interpretation parser, respectively.
[0146]
At the time of this output, the parser code creation means 150 outputs only the data type parsing code of the return value required for parsing on the client side as a client non-recursive data expression interpretation parser, and outputs the data of the argument required for parsing on the server side. Output only the code that parses the type as a server non-recursive data representation interpretation parser.
[0147]
When the server having the application to be started is the existing server 710, the HTTP client 230 sends the HTTP client / server 420 via the client-to-protocol converter network 600 by adding an HTTP header to the lightweight data transfer protocol format. I do.
[0148]
The HTTP client / server 420 receives the lightweight data representation protocol with the HTTP header from the HTTP client 320 via the client-to-protocol converter network 600. The HTTP client / server 420 calls the protocol conversion module 410 to convert the received protocol into a format that can be interpreted by the existing server, and then converts the received protocol to the existing server 710 via the protocol converter-existing server network 700. The data is transferred in a format that can be interpreted by the server 710.
[0149]
The existing server 710 receives data in a format used by the existing server 710 from the HTTP client / server 420 via the protocol converter-existing server network 700, executes an application in the existing server 710, and executes the protocol. The return value is returned to the HTTP client / server 420 via the converter-existing server network 700 in the format used by the existing server 710. The client-to-protocol converter network 600 is a normal TCP / IP network. The protocol converter-existing server network 700 is a normal TCP / IP network.
[0150]
In the above-described second embodiment, the interface description language compiler uses the interface description language input to generate a minimum required client non-recursive data expression generation serializer for starting a server application, a client non-recursive data expression interpretation parser, a server Since the non-recursive data expression interpretation parser and the server non-recursive data expression generation serializer are generated, the program size used by the client and the server can be reduced. Therefore, it is particularly effective when the above-described function is incorporated in a device having a limited disk capacity, such as a device having no hard disk drive. Also, the interface description language compiler generates a protocol conversion module from the input of the existing server's interface description language, so that the client using the reduced data representation protocol for the data transfer format and the service of the existing server can be used. Cooperation is possible.
[0151]
Next, the operation in the second embodiment will be specifically described with reference to FIGS.
[0152]
The interface description language interpreting unit 110 receives an input based on the WSDL interface description shown in FIG. 13 and extracts the used data type information without duplication. Specifically, “xsd: complexType” on line 11 in FIG. 13, “xsd: string” on line 12 and “xsd: boolean” on line 26 are extracted. At this time, the same expressions as “xsd: string” and the like appearing in other lines are not extracted.
[0153]
Next, the interface description language interpreting means 110 sends the extracted “xsd: complexType”, “xsd: string”, and “xsd: boolean” to the data type correspondence definition means 120. The data type correspondence definition means 120 determines that “xsd: complexType” is structural data, “xsd: string” is a character string type, and “xsd: boolean” is a boolean value type, and determines the result. It is sent to the interface description language interpreting means 110. The interface description language interpreting means 110 sends to the serialization code creating means 130 information that the structured type data and the character string type data are arguments and the boolean type is a return value.
[0154]
Next, on the one hand, the serialization code creation means 130 generates a serialization code of the structural type data and the character string type data, which are the arguments, and outputs it to the client non-recursive data expression generation serializer 230 as a client non-recursive data expression generation serializer. On the other hand, it generates a code for serializing the boolean data and outputs it to the server non-recursive data expression generation serializer 350 as a server non-recursive data expression generation serializer.
[0155]
Next, the interface description language interpreting means 110 sends to the conversion program creating means 140 information that the structured data and the character string data are arguments and the boolean data is a return value. The conversion program generation means 140 generates a mutual conversion program between the format used by the client and the format used by the existing server in the structural data, the character string data, and the boolean data, and sends the protocol conversion module 410 Output as a conversion module.
[0156]
Next, the interface description language interpreting means 110 sends information to the parser code creating means 150 that the structural type data and the character string type data are arguments and the boolean type data is a return value. The parser code creating means 150 generates a parsing code of the structured data and the character string data, which are the arguments, and outputs the generated code to the server non-recursive data expression interpretation parser 320 as a server non-recursive data expression interpretation parser. Then, a parsing code for the boolean type data is generated and output to the client non-recursive data expression interpretation parser 250 as a client non-recursive data expression interpretation parser.
[0157]
In the case of the second embodiment described above, the system generates codes only for serialization, parsing, and protocol conversion modules of only the types defined in the interface description language, so that array type data, character string type data, Further, it is not necessary to store codes of basic type data not used this time other than the truth type data, for example, integer value type data in the client, the server, and the protocol converter, thereby reducing a necessary disk area. For serialization or parsing, the relationship between the argument and the return value is also checked, and only the code for the serialization of the argument and the return value is parsed on the client side, and only the code for the argument parse and the return value is serialized on the server side. It is possible to reduce the required amount of code by arranging it.
[0158]
【The invention's effect】
A first effect is that a text document passed between a client and a server can be converted between a data type of a programming language and a text document at a high speed.
[0159]
The reason is that even when expressing structured data, at most one hierarchy is included, so when a multi-level hierarchy is included, the class representing the complexity of the grammar becomes a grammar context-free grammar. This is because it can be expressed by a regular grammar that can be interpreted more quickly.
[0160]
The second effect is that, since the size of a program for interpreting a text document passed between a client and a server can be reduced, it can be easily operated on a terminal with a small resource such as not having a hard disk. .
[0161]
The reason is that it is possible to assume that the text document passed between the client and the server has a hierarchical structure of at most one level. Therefore, the parsing program itself is compared with an XML parser that allows a multi-level hierarchy. This is because it can be made smaller.
[0162]
A third effect is that service cooperation between a client using the lightweight data representation protocol as a data transfer format and an existing server can be performed.
[0163]
The reason is that a module for converting between the lightweight data expression protocol and the existing protocol, that is, a protocol conversion module, can be generated from the input in the interface description language of the existing server.
[0164]
A fourth effect is that a program of a part for converting between a lightweight data expression protocol and a data format of a programming language in a client and a server can be reduced in size, and the disk capacity is limited without having a hard disk drive. This means that the disk capacity of the device can be used effectively.
[0165]
The reason is that from the input by the server-side interface description language, the minimum required client non-recursive data expression generation serializer for starting the server application, the client non-recursive data expression interpretation parser, the server non-recursive data expression interpretation parser, This is because a server non-recursive data expression generation serializer can be generated.
[Brief description of the drawings]
FIG. 1 is a diagram showing a block configuration of a first embodiment according to the present invention.
FIG. 2 is a diagram showing a sequence operation corresponding to the block configuration of FIG. 1;
FIG. 3 is a diagram showing a method format of a server application used in the embodiment shown in FIG. 1;
FIG. 4 is a diagram showing a processing flow of a client serialization unit in the embodiment shown in FIG. 1;
FIG. 5 is a diagram showing information on a memory of a client structure type array information table creating unit and a client non-recursive data expression document creating unit after a processing flow of a client serializing unit shown in FIG. 1;
FIG. 6 is a diagram showing a lightweight data representation protocol used in the embodiment shown in FIG. 1;
FIG. 7 is a diagram showing a processing flow in a server non-recursive data expression interpretation parser used in the embodiment shown in FIG. 1;
FIG. 8 is a diagram showing a processing flow in a server non-recursive data expression generation serializer used in the embodiment shown in FIG. 1;
FIG. 9 is a diagram showing a processing flow in a client non-recursive data expression interpretation parser used in the embodiment shown in FIG. 1;
FIG. 10 is a diagram showing a lightweight data representation protocol sent from a client to a server in the embodiment shown in FIG. 1;
FIG. 11 is a diagram showing a lightweight data representation protocol sent from a server to a client in the embodiment shown in FIG. 1;
FIG. 12 is a diagram illustrating a block configuration according to a second embodiment of the present invention.
FIG. 13 is a description example in an interface description language used in the embodiment shown in FIG. 12;
FIG. 14 is a diagram showing a block structure of a conventional SOAP.
FIG. 15 is a diagram showing a block structure of a conventional IDL compiler.
[Explanation of symbols]
100 Interface description language compiler
110 Interface description language interpreter
120 Data type correspondence definition means
130 Serialization code creation means
140 Conversion program creation means
150 Parser code creation means
200 clients
210 Client Application
220 Client library for non-recursive data representation
230 Client non-recursive data representation generation serializer
231 Client serialization unit
232 Client structure type array information table creation means
233 Client non-recursive data expression document creation means
240 HTTP client
250 Client non-recursive data representation parser
251 Client Perspective
252 Client header information creation means
253 Client ID pointer table
254 Client parameter information creation means
255 programming language return value creation unit
300 servers
310 HTTP server
320 Server non-recursive data expression interpretation parser
321 Server Perspective
322 server header information creation means
323 server ID pointer table
324 Server parameter information creation means
325 Server application startup information creation unit
330 Server Application Management
340 server application
350 Server non-recursive data representation generation serializer
351 Server serialization section
352 Server structure type array information table creation means
353 Server non-recursive data expression document creation means
400 protocol converter
410 Protocol conversion module
420 HTTP Client / Server
500 networks
600 Client-to-protocol converter network
700 Protocol converter-existing server network
710 Existing server

Claims (15)

In a service cooperation system between a client and a server using a data transfer protocol,
A client non-recursive data expression generation serializer that creates structural type data and basic type data of a programming language into a text document having at most one level of hierarchy that can be inversely converted at a destination;
A server non-recursive data expression interpretation parser that interprets a text document having at most one level of hierarchy created by the client non-recursive data expression generation serializer and extracts information necessary for starting a server application;
A server non-recursive data expression generation serializer that creates the structured type data and the basic type data, which are the return values that have started the server application, in a text document that can be inversely converted on the client side at the highest level,
By having a client non-recursive data representation parser that inputs a text document with at most one level of hierarchy and creates a parameter with a structure that is the return value from the server application,
A service cooperation system which enables cooperation between a client application and a server application. In a service cooperation system between a client and a server using a data transfer protocol,
The client,
A client serialization unit for inputting structural type data and basic type data of a programming language;
Client structured type array information table creating means for inputting the structured data from the client serializing unit and creating a table indicating the hierarchy of the structured data,
Receiving the basic type data from the client serializing unit and the table from the client structured type array information table creating means as input, and from this input, a text document that can be inversely converted at the highest hierarchy and at the destination is sent. Client non-recursive data representation document creating means for creating, and said server,
A server parsing section for inputting a text document having at most one level of hierarchy,
Server header information creating means for creating a name of a server application to be started and a function name by inputting a header part from the server parse part to a delimiter of a text document
A server parameter for inputting a main part of a text document from the server parse section and creating a parameter having a structure for starting a server application while using a server ID pointer table for temporarily holding hierarchical link information. Information creation means,
The name of the server application and the name of the function are input from the server header information generating means, and the parameters having a structure used for starting the server application are input from the server parameter information generating means, and are collected into information necessary for starting the server application. A server application start information creation unit,
A service cooperation system which enables cooperation between a client application and a server application. In a service cooperation system between a client and a server using a data transfer protocol,
The server comprises:
A server serialization unit for inputting structural type data and basic type data which are return values that have started the server application,
Server structured type array information table creating means for inputting the structured type data from the server serializing unit and creating a table indicating the hierarchy of the structured type data,
A server non-recursive that inputs a basic type data from the server serializing unit and the table from the server structure type array information table creating unit to create a text document that can be reverse-converted at the highest hierarchical level and at the destination. Data representation document creation means, and the client,
A client parsing section for inputting a text document having at most one level of hierarchy,
Client header information creating means for inputting a header portion from the client parse part to a delimiter of a text document and creating information indicating whether or not the server application has been normally started,
A client that inputs a main part of a text document from the client parse unit and creates a parameter having a structure that is a return value from a server application while using a client ID pointer table that temporarily holds hierarchical link information. Parameter information creation means,
From the client header information creating means, information indicating whether the server application has been started normally, and from the client parameter information creating means, a parameter having a structure that is a return value from the server application, A programming language return value creation unit that collects information to be received and returned to the client application,
A service cooperation system which enables cooperation between a client application and a server application. In one of claims 1 to 3,
The server non-recursive data representation parser,
A server parsing unit that inputs a text document having at most one level of hierarchy,
Server header information creation means for creating a name and a function name part of a server application to be started by inputting a header part from the server parse part to a delimiter of a text document,
Server parameter information creating means for creating a parameter having a structure for starting a server application while using a server ID pointer table for temporarily storing link information of hierarchical relations by inputting a main part of a text document from the server parse section When,
A server application that receives as input the name and function name of the server application received from the server header information creating means and parameters having a structure used for starting the server application received from the server parameter information creating means, and collects information necessary for starting the server application. A service cooperation system comprising an activation information creation unit. In one of claims 1 to 3,
The client non-recursive data representation parser,
A client parsing section for inputting a text document having at most one level of hierarchy,
Client header information creating means for inputting a header portion from the client parse part to a delimiter of a text document and creating information indicating whether or not the server application has been normally started,
A client that inputs a main part of a text document from the client parse unit and creates a parameter having a structure that is a return value from a server application while using a client ID pointer table that temporarily holds hierarchical link information. Parameter information creation means,
Information indicating whether or not the server application has been normally started from the client header information creating means, and a parameter having a structure that is a return value from the server application from the client parameter information creating means, respectively, A service cooperation system, comprising: a programming language return value creation unit that summarizes information to be returned to a client application. In one of claims 1 to 3,
The client non-recursive data representation generation serializer,
A client serialization unit for inputting structural type data and basic type data of a programming language;
Client structured type array information table creating means for inputting the structured data from the client serializing unit and creating a table indicating the hierarchy of the structured data,
A client non-recursive which inputs a basic type data from the client serialization unit and the table from the client structure type array information table creating means to create a text document which can be inversely converted at a destination at the highest hierarchical level. A service cooperation system comprising a data expression document creating means. In one of claims 1 to 3,
The server non-recursive data representation generation serializer,
A server serialization unit for inputting structural type data and basic type data which are return values that have started the server application,
Server structured type array information table creating means for inputting the structured type data from the server serializing unit and creating a table indicating the hierarchy of the structured type data,
A server non-recursive that inputs a basic type data from the server serializing unit and the table from the server structure type array information table creating unit and creates a text document that can be reverse-converted at the highest hierarchy and at the destination. A service cooperation system comprising a data expression document creating means. In a service cooperation method between a client and a server using a data transfer protocol,
When the client receives as input structural type data and basic type data of a programming language,
The structured data is created in a table indicating the hierarchy of the structured data, and the basic data and the table are each created in a text document that can be reverse-converted at the highest hierarchy and at the destination and transmitted to the server. Sending, and the server, when input from the client a text document having at most one level of hierarchy,
Using a server ID pointer table that creates a name of a server application to be started and a function name portion from a header portion up to a delimiter of the text document and temporarily stores link information of a hierarchical relationship from a main portion of the text document. While creating a parameter having a structure used for starting the server application, and compiling information necessary for starting the server application from each of the name and function name of the server application and the parameter having a structure used for starting the server application Service cooperation method characterized by the following. In a service cooperation method between a client and a server using a data transfer protocol,
When the server receives as input the structured type data and the basic type data that are the return values that have started the server application,
Create a table indicating the hierarchy of the structured data from the structured data, and create a text document that can be inverted at the destination at the highest hierarchy and from the respective basic data and the table and send it to the client. And
When the client receives an input of a text document having at most one level from the server,
Create information indicating whether the server application was successfully started from the header portion up to the delimiter of the text document,
From the main part of the text document, a parameter having a structure that is a return value from the server application is created using a client ID pointer table that temporarily holds link information of a hierarchical relationship, and the server application is activated. A service coordination method comprising: collecting information to be returned to a client application from information indicating whether or not the process has been performed normally and parameters having a structure that is a return value from the server application. In a service cooperation method between a client and a server using a data transfer protocol,
The server stores information necessary for starting a server application,
When a text document with at most one level of hierarchy is received,
A server ID pointer table for creating a name of a server application to be started and a function name portion from a header portion up to a delimiter of the text document and temporarily storing link information of a hierarchical relationship from a main portion of the text document. Create a parameter with the structure used to start the server application while using it,
A service coordination method characterized by combining from each created one. In a service cooperation method between a client and a server using a data transfer protocol,
The client sends information to be sent back to the client application,
When a text document with at most one level of hierarchy is received,
From the header part up to the delimiter of the text document, create information indicating whether or not the server application has been normally started, and temporarily hold hierarchical link information from the main part of the text document. Create a parameter with a structure that is the return value from the server application using the client ID pointer table,
A service coordination method characterized by combining from each created one. In a service cooperation method between a client and a server using a data transfer protocol,
The client, when receiving a text document to be sent to the server as input of structured type data and basic type data of a programming language, creates a table indicating a hierarchy of the structured type data from the structured type data, and A service cooperation method, wherein the service is created from each of the basic type data and the table so as to be able to perform reverse conversion at the highest hierarchy and at the destination. In a service cooperation method between a client and a server using a data transfer protocol,
When the server receives the text document to be sent to the client as input of the structured data and the basic data that are the return values of starting the server application, the server indicates the hierarchy of the structured data from the structured data. A service cooperation method, wherein a table is created, and the table is created from the basic type data and the table so as to be able to perform reverse conversion at the highest hierarchy and at the destination. In a service cooperation system between a client and a server using a data transfer protocol,
A client non-recursive data expression generation serializer that converts only parameters necessary for starting a server application in a client from a interface description language of an existing server using an interface description language into a text document;
A server non-recursive data expression interpretation parser that reversely converts a text document converted by the client non-recursive data expression generation serializer in a server and extracts parameters necessary for starting a server application;
A server non-recursive data representation generation serializer that serializes the return value in the programming language from the server application into a text document,
A client non-recursive data representation interpretation parser that returns a return value converted to a text document by the server non-recursive data representation generation serializer to a data type in a programming language;
Service cooperation comprising: an interface description language compiler that generates a protocol conversion module that converts a parameter converted into a text document by the client non-recursive data expression generation serializer into a form required for starting an existing server. system. 15. The interface description language compiler according to claim 14,
An interface description language interpreting means for inputting and interpreting an interface description language of an existing server in an interface description language;
Data type correspondence definition means for taking the correspondence between the data type and the content interpreted by the interface description language interpretation means;
A client non-recursive data expression generation serializer that receives data type information from an interface description language interpreter associated with a data type and converts only parameters necessary for starting a server application in a client into a text document;
Serialization code generation means for generating a server non-recursive data representation generation serializer for serializing a return value in a programming language from a server application into a text document;
Parser code creating means for creating a code of a server non-recursive data expression interpretation parser which reversely converts a text document converted by the client non-recursive data expression generation serializer in a server and extracts parameters necessary for starting a server application;
Parser code generating means for generating a client non-recursive data expression interpretation parser code for returning a return value converted to a text document by the server non-recursive data expression generation serializer to a data type in a programming language;
A service coordinating system comprising: a conversion program creating unit that creates a protocol conversion module that converts a parameter converted into a text document by the client non-recursive data expression generation serializer into a format required for starting an existing server.

Images