JP6112978B2 - RDF expression generation method, program, and system - Google Patents

Description

  The present invention relates to a technique for generating an RDF expression from predetermined data by computer processing.

  In recent years, as described in Japanese Patent Application Laid-Open No. 2005-242934 or Japanese Patent Application Laid-Open No. 2006-302085, an RDF (Resource Description Framework) format has been adopted as a mechanism for describing resources on the web. In addition, Christian Bizer, Tom Heath, Tim Berners-Lee, Linked Data-The Story So Far, International Journal on Semantic Web and Information Systems, 5 (3), 2009 Linked Data used in conjunction is described as a global information disclosure mechanism. Furthermore, Open Services for Lifecycle Collaboration (OSLC), http://open-services.net/ describes that Linked Data is used as information linkage within a company.

  There are two types of tools that provide Linked Data: tools that store and provide RDF data, and tools that convert non-RDF data managed by existing tools into RDF.

  In addition, tools that use Linked Data include tools that follow links according to user requests and obtain data, and tools that crawl linked data provision tools and create indexes in advance to improve data access efficiency. There is.

  FIG. 1 is a diagram showing an example of a configuration in which a plurality of computers are connected to a network in order to use such a tool. That is, computers 104, 106, 108, 110, 112, 114, 116, and 118 are connected to a network 102 that is typically a LAN or WAN. The computer 104 and the computer 110 store tools that store and provide RDF data.

  The computer 116 stores a tool for obtaining data by following a link in accordance with a user request. The computer 118 stores a tool for creating an index by crawling a linked data providing tool in advance for efficient data access.

  As shown in FIG. 1, in order to make many applications correspond to Linked Data, it is necessary to convert the objects of each application as RDF.

  For this reason, there is a configuration shown in FIG. 2 as one of known prior arts. In such a configuration, the entire object repository 202 is collectively and statically converted to RDF 204, and in response to a query by URI 208 from Linked Data usage tool 206, this configuration returns a corresponding RDF 210. However, in such a configuration, if even a part of the object repository 202 is updated, it is necessary to redo the conversion of the entire object repository 202 into the RDF 204, which is inefficient.

  Therefore, a configuration shown in FIG. 3 is known as a conventional technique for improving this. In such a configuration, there is a code 310 that receives the URI 304 from the Linked Data usage tool 302, makes an API call 306, and accesses the object repository 308. The code 312 extracts the object 312 from the object repository 308, and the RDF converter 314 refers to the mapping file 316 to generate the RDF 318 and passes it to the Linked Data usage tool 302. Such an API call 306 is described in, for example, http://jena.sourceforge.net/tutorial/RDF_API/. The mapping file is a file that defines rules such as dependency and hierarchy of RDF conversion. However, in such a configuration, when the RDF specification changes and a necessary object is changed, the code 310 for accessing the repository inevitably needs to be changed. At this time, if the object is complicated, for example, the number of properties of the object is large, there is a problem that it is easy to introduce a bug in the code 310 change.

  The technique described in the specification of Japanese Patent Application No. 2012-162030 relating to the applicant of the present application is related to the improvement of the above-described conventional technique, and receives a URI from a tool that uses Linked Data, etc. Identify, then identify the appropriate mapping file from the object's type, generate (partial) type information from it, refer to the generated type information, and recurse from the seed to collect objects The system then passes the collected object graph to the RDF converter, which refers to the mapping file to describe the technique of converting the object graph to RDF and outputting it. However, a limitation of this technique is that it assumes a fine-grained application programming interface (API) where the data can be directly accessed individually as objects and their property values, and a general API that returns structural data at once. There was a case that it doesn't correspond to the application you have. In other words, the API call / result interpretation and mapping mechanism are integrated, so data processing such as summing up values, selecting by conditions, and reformatting values can be done only within a predefined and fixed range. I can't.

JP 2005-242934 A JP 2006-302085 A Japanese Patent Application No. 2012-162030

Christian Bizer, Tom Heath, Tim Berners-Lee, Lined Data-The Story So Far, International Journal on Semantic Web and Information Systems, 5 (3), 2009 Open Services for Lifecycle Collaboration (OSLC), http://open-services.net/ http://jena.sourceforge.net/tutorial/RDF_API/

  Therefore, an object of the present invention is to provide an RDF generation technique that can be applied to an application having a general API that returns structure data.

  The present invention performs recursive lazy evaluation of rules based on annotations assigned to classes in a computer programming language, thereby obtaining an application object set, converting it into a user-defined class object, and further converting it into RDF. Thus, the above problem is solved.

The preferred computer programming language used here is Java (R), and the annotation is an annotation attached to a Java (R) class. In the present invention, annotation is used for the following three purposes.
-Specify the API and parameters of the external application to be called corresponding to the language element.
-Specify the mapping from the application data obtained by API to the Java (R) object.
-Specify the mapping from Java (R) objects to RDF expressions.

The system according to the present invention performs the following steps to generate an RDF representation.
-Parsing the received URI and obtaining the root class name and API parameters.
A step of generating one root class object.
-Extracting object class annotations that specify external application APIs and parameters, configuring API calls, and executing them to obtain data.
Extracting object class annotations that specify mapping to Java objects from the application data, generating objects as needed, and setting local variables accordingly. At this time, if there is an annotation specifying the external application API in the annotation of the generated object class, the process returns to the data acquisition step.
A step of generating an RDF expression for the generated object according to an annotation for mapping from an object of the class to RDF.

  According to the present invention, a structure corresponds to a Java object, a table corresponds to an array of objects, a tree-like data corresponds to a composite object, etc., with respect to application data acquired by the API. be able to.

  In addition, the body of the setter method that sets a local variable can be replaced with arbitrary data processing using a programming language, such as aggregating values, selecting by condition, and reformatting values.

  Furthermore, by making it possible to describe the data correspondence by separating the dependency of the application-specific API, data processing in a programming language can be freely inserted in the middle of mapping as necessary.

1 is a schematic diagram of a system configuration including a plurality of computers connected to a network including a Linked Data conversion / providing tool and a Linked Data using tool. FIG. It is a figure which shows the prior art for providing RDF corresponding to URI. It is a figure which shows another prior art for providing RDF corresponding to URI. It is a block diagram of the hardware constitutions for carrying out the present invention. It is a block diagram of the functional element for implementing this invention. It is a figure which shows the flowchart of a process of the RDF expression production | generation program of this invention. It is a figure which shows a mode that data are sent from a server with respect to the data request by API from a client computer. It is a figure which shows the object of a root class in an operation example. It is a figure which shows the structure of the data acquired from the server. It is a figure which shows the produced | generated object of the class by which the hierarchy was carried out. It is a figure which shows the produced | generated object of the class by which the hierarchy was carried out. It is a figure which shows the produced | generated object of the class by which the hierarchy was carried out. It is a figure which shows the object of a root class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example. It is a figure which shows the object of the produced | generated hierarchy class in another process example.

  Embodiments of the present invention will be described below with reference to the drawings. It should be understood that these examples are for the purpose of illustrating preferred embodiments of the invention and are not intended to limit the scope of the invention to what is shown here. Further, throughout the following drawings, the same reference numerals denote the same objects unless otherwise specified.

  FIG. 4 is a block diagram showing an example of computer hardware for carrying out the present invention. 4 includes a client computer 400, a network 420, and a server 430 connected to the client computer 400 via the network 420.

  In the client computer 400, a CPU 404, a main memory (RAM) 406, a hard disk drive (HDD) 408, a keyboard 410, a mouse 412, and a display 414 are connected to the system bus 402. The CPU 404 is preferably based on a 32-bit or 64-bit architecture, for example, Intel Core (TM) i3, Core (TM) i5, Core (TM) i7, Xeon (R), AMD's Athlon (TM), Phenom (TM), Sempron (TM), etc. can be used. The main memory 406 preferably has a capacity of 8 GB or more, and more preferably has a capacity of 32 GB or more.

  The hard disk drive 408 stores an operating system. The operating system can be any compatible with the CPU 404, such as Linux (trademark), Microsoft Windows (trademark) 7, Windows 8 (trademark), Windows (trademark) 2008 server, Apple Mac OS X (trademark), etc. Things can be used. In this embodiment, the hard disk drive 408 further stores a Java® Runtime Environment program for realizing a Java® virtual machine (JVM).

  The hard disk drive 408 further stores a main program 502, a URI input routine 504, an annotated Java (R) class definition file 506, an RDF expression generation program 508, and the like, which will be described later with reference to FIG.

  The main program 502, the URI input routine 504, and the RDF expression generation program 508 are executed by a compiler that can generate an executable code suitable for the CPU 404 by an existing programming language processing system such as C, C ++, or Java (R). Can be created.

  The keyboard 410 and the mouse 412 are used to operate graphic objects such as icons, task bars, and text boxes displayed on the display 414 in accordance with a graphic user interface provided by the operating system.

  The display 414 is preferably, but not limited to, a 32-bit true color LCD monitor with a resolution of 1024 × 768 or higher. The display 414 is used, for example, to display a screen for operating the RDF conversion process.

  The communication interface 416 is preferably connected to the network 420 by the Ethernet (R) protocol. A server 430 storing the entire application data 514 is connected to the network 420, and the client computer 400 requests data from the server 430 in accordance with a predetermined API for generating an RDF expression. Note that the network 420 may be an arbitrary network such as the Internet, a LAN, or a WAN.

  Next, functional elements for executing the processing of the present invention will be described with reference to FIG. In FIG. 5, the main program 502 has a function of requesting data from the server 430 via the communication module 516 and integrating other overall processing.

  The URI input routine 504 receives a URI from an application operating locally on the client computer 400 or a remote computer system connected via the network 420.

The annotated Java (R) class definition file 506 is created in advance by the user or the like for the processing of the present invention, and is preferably stored in the hard disk drive 408.
The method for adding annotations to Java (R) classes follows the JavaBeans naming convention. Ie:
Getter method
public
The name starts with get followed by the property name with the first letter capitalized.
The return type with no parameters is the type of the corresponding property
Setter method
public
The name begins with set followed by the property name with the first letter capitalized.
Parameter is the type of the corresponding property return type is void
The property
private field variables Accessible only through its Getter and Setter methods.
Furthermore, Java (R) class definition properties to which annotations are added have a restriction that the property type must be a concrete class or an array of concrete classes. Annotation to a Java (R) class can be preferably performed using an integrated development environment such as Eclipse (trademark). An example of an annotated Java (R) class will be described later.

  Based on the URI received from the URI input routine 504, the RDF expression generation program 508 generates a Java object of the annotated Java (R) class in accordance with the annotated Java (R) class definition, and executes an API call configured according to the annotation. Then, a part of the entire application data 514 stored therein is acquired from the server 430 by an API call via the communication interface 416. Then, it is stored in the main memory 406 of the client computer 400 as a part 510 of the acquired application data for processing. The RDF expression generation program 508 generates a Java (R) object according to the application, and sets a variable from a part of the acquired application data. The RDF expression generation program 508 generates an RDF expression 512 based on the composite Java (R) object obtained by such processing, and preferably stores it in the hard disk drive 408. Details of such processing will be described later with reference to the flowchart of FIG.

  The server 430 extracts part of the data from the entire application data 514 and transmits the data to the client computer 400 in accordance with the API processing routine 516 and API processing routine 516 of the API received from the client computer 400. A data transmission routine 518 is included. In one example, the external application stored in the server 430 is SAP ERP, and the API is SAP BAPI.

  Next, processing of the RDF expression generation program 508 will be described with reference to the flowchart of FIG.

  In step 602 of FIG. 6, the RDF expression generation program 508 analyzes the URI received from the URI input routine 504, and generates a root class name and an API parameter.

  In step 604, the RDF expression generation program 508 generates a Java (R) object of the root class according to the annotated Java (R) class definition based on the generated root class name and API parameter.

  In step 606, the RDF expression generation program 508 calls an API according to the generated Java (R) object annotation, and acquires a part of the data from the entire application data 514 of the server 430.

  In step 608, the RDF expression generation program 508 generates a Java (R) object from a part of the data according to the annotation of the generated Java (R) object, and sets a local variable.

  In step 610, the RDF expression generation program 508 determines whether there is any that specifies the external application API in the annotation of the Java (R) object class generated in step 608, and if so, returns to step 606.

  If there is no specification of the external application API in the annotation of the class of the Java (R) object generated in step 608, the RDF expression generation program 508 causes the plurality of Java (R) objects generated so far in step 612. RDF expression is generated according to the annotation. In addition, ELMO (http://www.openrdf.org/doc/elmo/1.4), Jenabean (http://code.google.com/p/jenabean) are technologies for converting user-defined class objects into RDF expressions. /), OSLC4J (http://wiki.eclipse.org/Lyo/LyoOSLC4J), etc., and in step 612, any of these existing technologies can be used.

  Next, an annotated Java (R) class definition and its processing in an example application implementing the present invention will be described.

  The classes used here are PurchaseOrder, POHeader, POItem, Vendor, and VCard, and the contents are as follows.

// class PurchaseOrder
@ApiCall (name = "BAPI_PO_GETDETAIL1", params = {"PURCHASEORDER"})
@OslcNamespace ("http://yourcompany.com/ns/sap#")
public final class PurchaseOrder {
private String id;
public String getId () {
return id;
}
public void setId (String id) {
this.id = id;
}
private POHeader poHeader;
@FieldName ("POHEADER")
@OslcValueType (ValueType.LocalResource)
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "poHeader")
public POHeader getPoHeader () {
return poHeader;
}
public void setPoHeader (POHeader poheader) {
this.poHeader = poheader;
}
private POItem poItem [];
@FieldName ("POITEM")
@OslcValueType (ValueType.LocalResource)
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "poItem")
public POItem [] getPoItem () {
return poItem;
}
public void setPoItem (POItem [] poitem) {
this.poItem = poitem;
}
}

// class POHeader
@OslcNamespace ("http://yourcompany.com/ns/sap#")
public final class POHeader {
private Vendor vendor;
@FieldName ("VENDOR")
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "vendor")
@OslcValueType (ValueType.LocalResource)
public Vendor getVendor () {
return vendor;
}
public void setVendor (Vendor vendor) {
this.vendor = vendor;
}
private Date created;
@FieldName ("CREAT_DATE")
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "created")
@OslcValueType (ValueType.DateTime)
public Date getCreated () {
return created;
}
public void setCreated (final Date created) {
this.created = created;
}
}

// class POItem
@OslcNamespace ("http://yourcompany.com/ns/sap#")
public final class POItem {
String materialNumber;
@FieldName ("MATERIAL")
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "materialNumber")
@OslcValueType (ValueType.String)
public String getMaterialNumber () {
return materialNumber;
}
public void setMaterialNumber (String materialNumber) {
this.materialNumber = materialNumber;
}
BigDecimal netPrice;
@FieldName ("NET_PRICE")
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "netPrice")
@OslcValueType (ValueType.Decimal)
public BigDecimal getNetPrice () {
return netPrice;
}
public void setNetPrice (BigDecimal netPrice) {
this.netPrice = netPrice;
}
String description;
@FieldName ("SHORT_TEXT")
@OslcPropertyDefinition ("http://purl.org/dc/terms/" + "description")
@OslcValueType (ValueType.String)
public String getDescription () {
return description;
}
public void setDescription (String description) {
this.description = description;
}
}

// class Vendor
@ApiCall (name = "BAPI_VENDOR_GETDETAIL", params = {"VENDORNO"})
@OslcNamespace ("http://yourcompany.com/ns/sap#")
public final class Vendor {
private String id;
public String getId () {
return id;
}
public void setId (String id) {
this.id = id;
}
private VCard detail;
@FieldName ("GENERALDETAIL")
@OslcValueType (ValueType.LocalResource)
@OslcPropertyDefinition ("http://yourcompany.com/ns/sap#" + "detail")
public VCard getDetail () {
return detail;
}
public void setDetail (VCard detail) {
this.detail = detail;
}
}

// class VCard
@OslcNamespace ("http://www.w3.org/2006/vcard/ns#")
public final class VCard {
String name;
@FieldName ("NAME")
@OslcPropertyDefinition ("http://www.w3.org/2006/vcard/ns#" + "fn")
@OslcValueType (ValueType.String)
public String getName () {
return name;
}
public void setName (String name) {
this.name = name;
}
String city;
@FieldName ("CITY")
@OslcPropertyDefinition ("http://www.w3.org/2006/vcard/ns#" + "adr")
@OslcValueType (ValueType.String)
public String getCity () {
return city;
}
public void setCity (String city) {
this.city = city;
}
}

In the class definition with annotation above,
@ApiCall specifies the API and parameters of the external application.
@FieldName is a correspondence from the field value of the acquired data to the Java (R) object.
@OslcNamespace
@OslcValueType
@OslcPropertyDefinition
Is a mapping from Java (R) objects to RDF expressions, and uses OSLC4J annotations.

  The API premised in this embodiment is that a plurality of structures and tables are returned to the client computer 400 from the server 430 at a time, and then the records and table data are accessed on the client side. If possible. Preferably, the structure here is an associative array of basic data. A table is an associative array of basic data. FIG. 7 is a diagram illustrating how the client computer 400 acquires data from the server 430 using the API.

At this time, how to pass parameters to the API is as follows.
(1) Use conventions related to field names In the following code, pass the values of fields id, id2, id3, .. to the API call as argument values specified in params.
@ApiCall (name = "BAPI_PO_GETDETAIL1", params = {"PURCHASEORDER”, “ITEMNO”})
public final class PurchaseOrder {
private String id;
private String id2;
}
If the values of id and id2 are 4500017172 and 0010, respectively, BAPI_PO_GETDETAIL1 (PURCHASEORDER = 4500017172, ITEMNO = 0010) is generated and called. In the case of an API in which arguments are specified in order instead of parameter names, params is not used in the annotation.

(2) Annotate the field name and specify that it will be used as an API call
@ApiCall (name = "BAPI_PO_GETDETAIL1", params = {"PURCHASEORDER”, “ITEMNO”})
public final class PurchaseOrder {
@ApiArgument (1)
private String po_num;
@ApiArgument (2)
private String item_num;
}

(3) Use convention regarding field names when there is no annotation-Combination of (1) and (2)

In the above configuration, a specific processing example will be described.
Assume that the RDF expression generation program 508 receives the URI http://example.com/purchaseOrders/4500017172 in step 602 of FIG. By analyzing this, the RDF expression generation program 508 obtains a root class name PurchaseOrder and a parameter 4500017172.

  Next, in step 604, the RDF expression generation program 508 generates a PurchaseOrder object, which is a Java (R) object of the root class, as shown in FIG.

Next, in step 606, the RDF expression generation program 508 makes an API call using @ApiCall that specifies the name and parameters of the external application API with the annotation of the class PurchaseOrder as follows.
BAPI_PO_GETDETAIL1 (PURCHASEORDER = 4500017172)
The result of executing this is returned from the server 430.
The return value of BAPI_PO_GETDETAIL1 is two Structures (a set of field name / value pairs) and 22 Tables (an array of field name / value pair sets). Each value can be uniquely retrieved by specifying the Structure name and field name, or the Table name, row number, and field name.
The data thus obtained is as shown in FIG.

  Next, in step 608, the RDF expression generation program 508 adds @FieldName (“POHEADER”) to the poHeader of class PurchaseOrder, and sets the current target SAP Structure to POHEADER. Then, an object of POHeader that is a class of poHeader is generated. Next, the entry value of POHEADER is accessed according to the field annotations @FieldName (“VENDOR”) and @FieldName (“CREAT_DATE”) of the class POHeader. Then, convert the obtained value to the type of each field of POHeder and substitute it using the Setter method. Next, the POHeader object is assigned as the poHeader field value of the PurchseOrder object. The objects obtained in this way are as shown in FIG.

  Next, since the RDF expression generation program 508 adds @FieldName (“POITEM”) to the poItem of the class PurchaseOrder, the current target SAP table is set to POITEM (whether the table or structure is an array) And generate a POItem object that is a class of poItem. Then, the POITEM entry value is accessed according to the field annotations @FieldName ("MATERIAL"), @FieldName ("NET_PRICE"), and @FieldName ("SHORT_TEXT") of the class POItem. Convert the obtained value to the type of each field of POItem and assign it using the Setter method. Then, the POItem object is assigned as the poItem field value of the PurchseOrder object. The objects obtained in this way are as shown in FIG.

Next, since the annotation of the class that has not yet been processed exists in the class Vendor of the generated object, the RDF expression generation program 508 returns to step 606 and performs the following API call specified by the annotation.
BAPI_VENDOR_GETDETAIL1 (VENDORNO = 0005)
The RDF expression generation program 508 extracts an entry value using the annotation of the field of the class VCard for the Structure GENERALDETAIL obtained by executing the API call, and substitutes it into the field. The objects obtained in this way are as shown in FIG.

  In this way, the RDF expression generation program 508 determines in step 610 that there is no specification of the external application API in the annotation of the generated object class, and in step 612, traverses the object graph shown in FIG. RDF expression is generated according to the annotation of mapping from object to RDF expression.

The RDF representation generated in this way is as follows.
<rdf: RDF
xmlns: sap = "http://yourcompany.com/ns/oslcbridge/sap#"
xmlns: rdf = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns: dcterms = “http://purl.org/dc/terms/”
xmlns: v = “http://www.w3.org/2006/vcard/ns#”>
<sap: PurchaseOrder rdf: about = "http://example.com/purchaseOrder/4500017172">
<sap: poHeader>
<sap: POHeader>
<dcterms: created> 2006-10-26T00: 00: 00.000 + 09: 00 </ dcterms: created>
<sap: vendor>
<sap: Vendor>
<sap: detail>
<v: VCard>
<v: fn> Safety Clean Inc. </ v: fn>
<v: adr> New York </ v: adr>
</ v: VCard>
</ sap: detail>
</ sap: Vendor>
</ sap: vendor>
</ sap: POHeader>
</ sap: poHeader>
<sap: poItem>
<sap: POItem>
<dcterms: description> Hydroxide Sludge </ dcterms: description>
<sap: materialNumber> IDES_WA_0001 </ sap: materialNumber>
<sap: netPrice> 250 </ sap: netPrice>
</ sap: POItem>
</ sap: poItem>
</ sap: PurchaseOrder>
</ rdf: RDF>

Next, an example of changing the behavior in the situation at the time of execution is shown.
First, the class definition is as follows.
@ApiCall (name = "BAPI_VENDOR_GETDETAIL", params = {"VENDORNO"})
public final class Vendor {
private String id;
@FieldName ("GENERALDETAIL")
private VCard detail;
}
public final class VCard {
@FieldName ("NAME")
String name;
@FieldName ("CITY")
String city;
@FieldName (“SUPPLIER”)
Vendorsupplier;
}

  Here, it is assumed that the initial object is as shown in FIG. Then, the RDF expression generation program 508 generates and executes a call BAPI_VENDOR_GETDETAIL (VENDORNO = 0005) with reference to the parameter of @ApiCall of the class Vendor of the initial object. As a result, the Structure shown in FIG. 14 is returned.

  Next, the RDF expression generation program 508 associates the property detail of the Vendor object with the returned SAP Structure GENERALDETAIL by @FieldName (“GENERALDETAIL”). Then, an object of class VCard of property detail is generated. The result is as shown in FIG.

  Next, the RDF expression generation program 508 sets a value according to the annotation of the class VCard. At this time, since Vendor is a class with @ApiCall, first create a Vendor object, and then set the value 0013 to the created Vendor. The result is as shown in FIG.

  Next, the RDF expression generation program 508 generates and executes a call BAPI_VENDOR_GETDETAIL (VENDORNO = 0013) with reference to the @ApiCall parameter of the new object class Vendor. As a result, the Structure shown in FIG. 17 is returned.

  Next, the RDF expression generation program 508 associates the property detail of the Vendor object with the returned SAP Structure GENERALDETAIL by @FieldName (“GENERALDETAIL”). Then, an object of class VCard of property detail is generated. The result is as shown in FIG.

  Next, the RDF expression generation program 508 sets a value according to the annotation of the class VCard. At this time, since there is no SUPPLIER value, no Vendor object is created. Stop because there is no unprocessed annotation. The result is as shown in FIG.

  Although the processing of the present invention has been described according to a specific embodiment, the present invention should not be construed as being limited to this specific configuration or embodiment. For example, the Java (R) definition with annotation is an example, and any programming language that allows annotated description such as C ++ can be used.

400: Client computer 404: CPU
406 ... Main memory 408 ... Hard disk drive 416 ... Communication interface 430 ... Server 506 ... Annotated Java class definition 508 ... RDF expression generation program

Claims (11)

A method of converting a URI into an RDF representation by computer processing,
Receiving a URI;
Analyzing the URI to obtain a root class name and API parameters;
Generating a root class object based on the root class name and annotated class definition of the program;
Calling the API according to the annotation of the root class and obtaining data;
Generating a program object from the data according to the annotation and setting a local variable;
Determining whether a code specifying an API is included in the annotation of the generated object class, and if so, calling the API according to the annotation and returning to the step of acquiring data; and
If the generated object class annotation does not include a code for specifying an API, an RDF expression is generated from the program object according to the annotation.
Method.   The method of claim 1, wherein the program is written in a class-based programming language that allows annotations to be added to classes and methods.   The method according to claim 2, wherein the program is Java®.   The method of claim 1, wherein generating the RDF representation is performed on a client computer, and data acquisition by the API is acquired from a different server than the client computer. A program that converts URIs into RDF expressions by computer processing,
In the computer,
Receiving a URI;
Analyzing the URI to obtain a root class name and API parameters;
Generating a root class object based on the root class name and annotated class definition of the program;
Calling the API according to the annotation of the root class and obtaining data;
Generating a program object from the data according to the annotation and setting a local variable;
Determining whether a code specifying an API is included in the annotation of the generated object class, and if so, calling the API according to the annotation and returning to the step of acquiring data; and
If code that specifies an API is not included in the annotation of the generated object class, the step of generating an RDF expression from the object of the program according to the annotation is executed.
program.   The program according to claim 5, wherein the program is written in a class-based programming language that allows annotations to be added to classes and methods.   The program according to claim 6, wherein the program is Java®.   6. The program according to claim 5, wherein the step of generating the RDF representation is executed on a client computer, and the data acquisition by the API is acquired from a server different from the client computer. A system that converts URIs into RDF expressions by computer processing,
Storage means;
Data of annotated class definition of the program stored in the storage means;
A means of receiving a URI;
Means for analyzing the URI and obtaining a root class name and API parameters;
Means for generating an object of a root class based on the root class name and by annotated class definition of the program;
Means for calling the API according to the annotation of the root class and acquiring data;
Means for generating an object of the program from the data according to the annotation and setting a local variable;
Determining whether the annotation of the generated object class includes a code specifying an API, and if so, calling the API according to the annotation and returning to the step of acquiring data;
If the generated object class annotation does not include a code for specifying an API, the device has means for generating an RDF expression from the program object according to the annotation.
system.   The system of claim 9, wherein the program is written in a class-based programming language that allows annotations to be added to classes and methods.   The system according to claim 10, wherein the program is Java®.

Images