KR20120078033A - Service mashup method and apparatus in environment of linked data - Google Patents

Abstract

PURPOSE: A service mash-up method in a linked data environment and a system thereof are provided to express a data service of linked data, an open API(Application Program Interface) and a RSS(Really Simple Syndication) feed as a single consistent data structure, thereby mashing up disparate data. CONSTITUTION: A validity checking module(202) receives a validity checking request message about information for a service configuration through a user terminal and confirms validity. A process issuing module(204) receives a process issuing request message including the information for the service configuration which the validity is confirmed and generates a URI(Uniform Resource ID) about the information. The process issuing module receives information about a process and the information for the service configuration and the URI and describes the process and includes a process description in order to issue a unit service.

Description

SERVICE MASHUP METHOD AND APPARATUS IN ENVIRONMENT OF LINKED DATA}

The present invention relates to a service mashup technique in a linked data environment, and more particularly, to a service mashup method and system in a linked data environment that can mash up data and services irrespective of the heterogeneity of the data.

 With the advent of the World Wide Web, anyone can freely find the information they want through the Internet, publish their information on the web, communicate with each other, and buy and sell things on the web. Web-oriented information environment has been created. This enables a new way of producing and using information, which is a different dimension than before. This new type of information environment has exploded and increased the amount of information produced, leading to a situation where the need for and meaningful information within it becomes a serious problem.

The existing web that we are familiar with consists of documents that are expressed in the form of interconnected HTML, and the connection between the actual web document and the real-world entity that it describes, that is, the understanding of meaning, is made by the person who reads the document. . For example, when a person wants to find relevant information to travel to Jeju Island, finding the travel information and map information about Jeju Island on the web, and connecting and combining the two informations to make the desired travel information is a human task. You must go through it. This is because HTML, the format for representing documents on the Web, was created for display purposes for human reading, and is a problem because the Web is merely a tool for conveying information and has no ability to understand and process it.

The Semantic Web is designed to solve this problem. Unlike the existing web based on HTML for human-centered data representation, the Semantic Web expresses the meaning of data on the web and provides automatic data exchange. It provides a Web of data that enables human and machine, machine and machine cooperation.

Tim Berners-Lee, the founder of the World Wide Web for this semantic web, gave the semantic web a well-defined meaning to information that allows the machine and humans to work better together. It is defined as an extension. In other words, the free exchange of data between various applications enables the integration and reuse of data, and furthermore, the web of data defined and connected in such a way that the machine can be used to enable automation by machines or agents. It is the vision of the Semantic Web.

Linked Data also enables open data over the network, flexibility and collaboration. In other words, SPARQL is used as a query language for accessing resources through Uniform Resource Identifier (URI) dereferences, publishing data to the web through machine-readable methods through the Resource Description Framework (RDF), and retrieving information published in RDF format. I use it. The above URIs, RDFs, and SPARQLs are all semantic web standards of the W3C, and linked data is a practical example of semantic web services. Wikipedia describes Linked Data as a term describing the best way to expose, share, and connect data, information, and knowledge on the Semantic Web using the Unified Rdsource Identifier (URI) and Resource Description Framework (RDF). have.

The current web only distributes information through well-processed and well-formed, expression-oriented web pages. But if you can link data from web pages, especially raw data, to related topics, a huge number of combinations can produce thousands and millions of different and beneficial results. However, data on the web is stored in a huge variety of forms, which are difficult to connect because they are in HTML format for document presentation.

On the other hand, the mashup that emerged due to the emergence of Web 2.0 can be characterized by an open API and content syndication using RSS / ATOM Feed. In addition, programming tools such as AJAX, JSON, and Flex make it easy and fast to create and share mashup applications that provide a rich user interface. However, these Web 2.0 mashups have different interfaces and different representations of the data, which means that program code must be added manually each time a data source is added. In addition, since the representation of data is not a format that can be understood by the machine, humans have to work individually, and the level of mashup remains at the interface level, and data reuse is difficult.

However, mashup of linked data based on semantic web data can be easily achieved by expressing data in RDF, a W3C semantic web standard format, and linking them together for machine understanding. That is, URIs starting with http: // "identify data and can be accessed by anyone through the web, so that even if the original data source is modified, the mashup can be dynamically reflected.

In addition, the data distinguished by URI is much more industrial value because it is reusable and easier to write than mashup using web API.

Mashed data also plays an important role in creating a virtuous cycle, or ecosystem, of linked data because it is a compatible standard format and can be input data for other mashups.

SparqlMotion from Top Quadrant, a semantic web mashup tool, uses URIs to access RDF data distributed across the web, and then combines the data into a visual flow editor that can be processed for any purpose. SPARQL, an OWL standard query language, allows you to filter data and create an intuitive flow diagram of OWL-modeled information so that users can easily create mashups. In addition, the SparqlMotion supports functions such as import, transformation, filtering, and search for various types of data such as XML, RSS Feed, and TEXT document, and the data flow diagram written is described in RDF. Saved as a script that can be reused. Recently, SPARQL queries have been added to allow external data to be queried by accessing an external SPARQL endpoint.

 However, the SparqlMotion is a product integrated with TopBraid Composer, an ontology modeling tool of Top Quadrant, and does not provide a web-based interface. A mashup created through SparqlMotion is published as a service only through TopQuadrant's semantic web application server.

The Digital Enterprise Research Institute (DERI) is the world's leading semantic web research institute, providing related technology research, industrialization and application solutions and leading the semantic web industry worldwide. The DERI Pipes is a semantic mashup platform for fusion and converged data of the linked data format distributed on the web. The DERI Pipes consists of a Pipes Editor, a Pipes Repository, and an Execution Engine, and the mashed up data is in RDF, RDF / JSON, Turtle / N3, TRIG, TRIX, NTRIPLES format. It may be provided as.

The Pipes editor is a lightweight web-based workflow editor that allows operators such as merge and split to process and flow data, and Sparql queries such as selects and constructs. Allows you to design data mashups through merging and filtering of data. This designed mashup is serialized to XML format and stored in the Pipes repository, which can be reused for other mashups.

The execution engine then loads the stored mashup and can be accessed from the web through HTTP content negotiation. Parameters can be defined as inputs of the pipe, and accordingly, applications or users using REST APIs can be defined by themselves or dynamically provided through HTTP get requests to reflect the latest dynamic data. Other advantages of DERI Pipes include support for RDFS-level inference and Sparql query processing, ensuring reusability of mashups, and dynamic data integration.

As mentioned above, linked data is the ultimate in semantic web to achieve the purpose of integrating and reusing heterogeneous data in a distributed web environment by building semantic data in a format that can be understood by both humans and machines. As a technical means for achieving the purpose, it is a base technology for achieving the semantic data environment.

In particular, a semantic data environment must be established through linked data to enable web-based intelligent services and innovative service implementation, which supports this point when the next-generation information and communication technology market is transitioning to a semantic data environment. There is an urgent need to secure a foundation solution for linked data.

However, most of the research and existing mashup tools that have been carried out to date only work on the same data types. That is, the representative mashups currently being conducted mainly research mashups between linked data and linked data, and mashups between open API and open API.

Accordingly, in the field of researching mashups between linked data (eg A. Nikolov, V. Uren, E. Motta, Data Linking: Capturing and Utilizing Implicit Schema-level Relations), an ontology such as DBPedia is used as a mediator. However, this also has a problem that can not be used when all the data required for the mashup is not published as Linked Data. Therefore, it is impossible to mash up with high-quality general web data, so there is a limit in using various data desired by users and creating new service. In addition, in the case of mashup between open APIs, which are widely used in the Web 2.0 environment, the results can be used only when the user manually executes programming. However, even in this case, there was a limitation that only the data disclosed by the information provider could be used.

Accordingly, various attempts have been made to use web data in the form of linked data. However, this remained largely at the stage of converting web data and web services to linked services. Therefore, in order to inherit and develop the net function of Web 2.0, even in the semantic web environment, user participation through mashup is required, and mashup is also essential for the diversification of data and services. However, since the heterogeneity of data acts as an obstacle to this problem, it is urgently required to develop a tool capable of mashing up data and services irrespective of the heterogeneity of data.

It is an object of the present invention to provide a method and system for mashing up a service in a linked data environment that can mash up data and services irrespective of the heterogeneity of the data in the linked data environment.

Service mashup system according to the present invention for achieving the above object, Validation module for receiving a validity check request message for information on the service configuration through the user terminal to verify the validity; Receiving a process issuance request message including the information for the service configuration is validated, generates a URI for the information for the service configuration, and inputs the URI, information for the service configuration and information about the process And a process issuing module for receiving a process and specifying a process and issuing a unit service including the process specification.

In addition, the service mashup system according to the present invention, a service storage; The selected unit service, a unit service stored in the service repository, and one or more services that are combined with one or more services generated are selected, and a URI for a new service is generated, and the composite service is composed of the URI and selected services. And specifying and publishing a service configuration module for storing the issued composite service in the service repository.

The present invention described above has an effect of enabling mashup of heterogeneous data by representing data and services such as linked data, open API, RSS feed, etc. in one consistent data structure.

The present invention makes it possible to mash up high-quality data having different data, thereby increasing data reusability, reproducing more high-quality data, and increasing data scalability and increasing data diversity. It can be higher and causes an effect that can widen the range of application of the data.

In addition, the present invention provides a mashup tool for the user, it is possible to perform the process of specification, publication, execution, etc. using the basic information input through the user screen. In this process, we also publish unit services and complex services, which are processes, and store them in the service repository so that users can reuse them. This may be an opportunity to increase the convenience of the user and lead to the expansion of the user's participation according to the improved convenience. Such increased user participation can lead to more participation, allowing data and services to be more diverse and new.

In addition, the present invention publishes a variety of heterogeneous data as a service of linked data, and in this process, the specification is performed in a consistent format and issued, and thus, efficiency can be expected in terms of data integration.

1 is a service modeling structure diagram according to a preferred embodiment of the present invention.
2 is a diagram illustrating a user screen of a service mashup system according to a preferred embodiment of the present invention.
3 to 7 are structural diagrams of a service mashup system according to a preferred embodiment of the present invention.

The present invention makes it possible to implement mashups for heterogeneous data and services and to minimize user effort for them. To this end, the present invention specifies heterogeneous data and services in a consistent manner, publishes services and performs mashups.

<Service Description>

First, a description of a service according to a preferred embodiment of the present invention will be described with reference to FIG. 1.

Since the service according to the invention is published as linked data, the service is specified based on the ontology model. That is, the collected data is specified in a process unit, and is issued as a service for subsequent service mashup, thereby facilitating the combination between services.

The above-described service according to the present invention is classified into an atomic service and a composite service. The unit service is a service having only one process, and the composite service is composed of one or more unit services and / or a combination of one or more composite services.

In particular, when the service according to the present invention is a complex service, the execution order for two or more services constituting the service is specified.

As such, specifying the order of execution of services is essential to increase the accuracy of mashup service execution.

1 is a model of the specification of a service according to the present invention.

Referring to FIG. 1, the specification of the service includes a specification of a service configuration, a specification of a data format of the service, and a specification of the service description.

First, a description of the service configuration will be described.

A service consists of one or more unit services and a composite service, which is described as rdfs: subClassOf. Configuration information for each service is described as compose / composedOf. If the service is a complex service, execution order information is specified, which is described as next, or previous.

The unit service includes a process, and each process has a message, which is described as hasMassage. And the message can include Result Message and Error Message, which is described as rdfs: subClassOf. The result message is described as massageCode, the data format for it is described as xsd: string, the error message is described as messageContent, and the data format for it is described as xsd: string.

The process also has parameters, the input and output of which are described as hasOutput and hasInput. The parameter is named paramName, and paramOrder is provided for describing an order between parameters as information required when invoking a process. In the process, a name is described as processName, a data type thereof is described by xsd: string, a description is described by description, and a data type thereof is described by xsd: string.

The specification of the data format for the service will be described.

The data format for the process is described as rdfs: subClassOf. The data format may be SparqlQuery, OpenAPI, RSS, or the like. The SparqlQuery describes structure and selection information through rdfs: subClassOf. In addition, the queryContent of the SparqlQuery and xsd: string thereof are described. The OpenAPI describes apiURLForm and its xsd: string. In addition, when OpenAPI needs API Key value, it describes through hasAPIKey. The RSS is described by rssTagging and xsd: string thereof.

A description of the service description will be described.

The service includes creator information and information on a title, a goal, a class code, and the like, and the creator information is described as dc: creator. The title information is described as dc: title. And the purpose of the service is described as a goal. The class code is described as classCode and serviceCode and rdf: type and skos: Contept. The class code generates a classification code for a service as an instance of skos: Concept according to the W3C standard knowledge vocabulary description standard SKOS, and takes a classification code that is an instance of skos: Concept as the classification code of the corresponding service through classCode. .

When a plurality of services are combined to form a service, a next relationship (previous) of execution order for the plurality of combined services is described. That is, among the services constituting the composite service, the first service has no specification about previous, and the last service has no next. In addition, the number of services included in the composite service is described as numberOfServices and xsd: integer.

A plurality of services constituting the composite service have an input, an output, and a parameter, and an input parameter of a service that comes first among the services constituting the composite service is It is the input of the composite service, and the output parameter of the service that comes last is the output of the composite service.

The above service, on the other hand, has a process abstracted into a unit service, which is described as hasProcess. The process has a message, which is described by hasMessage, which has a parameter, described by hasInput and hasOutput, which has a process type, described by hasType, the description is described by description and xsd: string, and the names are processName and xsd: Described as a string.

The type of the document that returns the result of the process is described as returmFormat, and the types such as RDF, JSON, and XML are described as rdf: type.

<Screen for service mashup>

2 illustrates a user screen for service mashup according to a preferred embodiment of the present invention.

The user screen for the service mashup is provided by the service mashup system according to the present invention, and includes a validity check screen 100, a unit service registration screen 102, and a service mashup screen 104.

The validity check screen 100 receives a URL and a query from a user, provides the service mashup system, and displays a result returned from the service mashup system.

The unit service registration screen 102 generates and guides a URI generated by the service mashup system according to a request from the user, receives a specification from the user, and registers the unit service according to the unit service registration request. The system may request a mashup for a unit service or a complex service registered in the service mashup system. In particular, the specification input on the unit service registration screen 102 guides the items to be specified, and when one item is selected, guides a list of the available specifications for the item, so that the service specification by the user can be easily performed.

The service mashup screen 104 guides the unit service or the composite service registered in the service mashup system according to a request from the user, and selects the unit service or the composite service according to the user's request to issue a service. Save as requested.

<Service Mashup System>

A configuration of a service mashup system according to a preferred embodiment of the present invention will be described with reference to FIG. 3.

The service mashup system 200 includes a validator 202, a process publisher 204, a service composer 206, and a service executor 208. It consists of. The service mashup system 200 is connected to a service repository 212 that stores various information and services issued during the service mashup process.

The validity check module 202 receives a URL and a query input by the user through the validity check screen 100 shown in FIG. 2 and checks the validity of the corresponding URL through a network, and checks the result of the validity check screen ( Guide the user through 100).

The process issuing module 204 generates and guides a URI for the unit service through the unit service registration screen 102 shown in FIG. 2, and receives a specification for the unit service input by the user. ) As a unit service.

The service configuration module 206 guides the list and information on the unit service and the complex services registered in the database 214 through the service mashup screen 104 shown in FIG. 2, and guides the unit service and the complex service. One or more and execution order information is selected by the user, and a service is issued and stored in the database 214.

The service execution module 208 executes the service according to the execution request for the service issued through the service mashup screen 104 shown in FIG.

Each configuration of the service mashup system 200 according to the preferred embodiment of the present invention described above will be described in detail with reference to the accompanying drawings.

<Validation module>

The configuration and operation of the validity checking module 202 according to the preferred embodiment of the present invention will be described in detail with reference to FIG. 4.

The validation module 202 is a module for checking the validity of data requested by the user and guiding the results, and includes a data acceptor 300, a validation checker 302, and a result handler. A result handler 304 and a connection manager 306.

The data acceptor 300 receives validity check request data including a URL and a query input by the user through the validity check screen 100 of the user terminal 210 and provides the validity checker 302 to the validity checker 302. The query input by the user is composed of a query and other parameter information in the case of an Open API, a keyword in the case of an RSS feed.

The validity checker 302 separates the validation request data into a URL and a query, and transmits the validation check request data to the connection manager 306.

The connection manager 306 receives the URL and the query, accesses the web resource according to the URL, delivers the query, and transmits the query to the validity checker 302 when a processing result of the query is provided from the web resource. . Here, when the URL is not valid or the processing result according to the query is invalid or the processing result value according to the query does not exist, the connection manager 306 is provided with a "Fault Message" as a result. In particular, the connection manager 306 manages a connection with an external web resource and stores information for accessing each web resource in advance.

When the validity checker 302 is provided with a "Fault Message" from the connection manager 306, the result handler 304 provides notification information indicating that the URL and query information input by the user is invalid. When the message is received, the result handler 304 provides notification information indicating that the URL entered by the user and the query are valid.

The result handler 304 guides the notification information to the user through the validity check screen 100 of the user terminal 210.

In addition, after the result handler 304 guides the notification information, when the user requests to store URL and query information through the validity check screen 100 of the user terminal 210, the URL, query, and validity check are performed. The result information is stored in the service repository 212 and provided to the process publishing module 204.

<Process Issuance Module>

The configuration and operation of the process issuance module 204 according to the preferred embodiment of the present invention will be described in detail with reference to FIG.

When the process issuance module 204 receives a process issuance request message including a URL and a query which has been validated through the validation module 202, the process issuance module 204 generates a URI and the URL and the query and the user terminal 210. Through the unit service registration screen 102 of the process, the information on the process is input, and the process is specified, and it is issued to the linked data-based unit service (Atomic Service). Here, the process issue request message includes a URL, a query, and a validity check result.

The process issuing module 204 includes a data acceptor 400, a URI generator 402, a data parser 404, and a process descriptor 406. It is composed of a process aggregator (408), a unit service register (Atomic Service Register) (410), a user input / output handler (User Input / output Handler) (412).

The data acceptor 400 receives a request for unit service registration and information for a unit service specification through the unit service registration screen 102 of the user terminal 210, and validates the data through the validity checking module 202. It receives a process issue request message containing the verified URL and query.

In response to the unit service registration request, the data acceptor 400 requests URI generation to the URI generator 402 and provides the data parser 404 with information for the URL, query, and unit service specification.

The URI generator 402 generates a URI according to the URI generation request. In the linked data, since each instance has a unique URI, a unique URI is required in order to make the input information from the user linked data. Accordingly, the present invention adopts a method of generating a URI in the system.

The data parser 404 divides information for URL and query and unit service specification, divides and extracts various information such as query / URL / Parameter into units that can be used for process specification, and transmits the information to the process descriptor 406. do.

The process descriptor 406 specifies, according to a predetermined process specification rule, information corresponding to a process specification among data provided from the data parser 404, and then provides the process to the process aggregator 408. Here, as the information corresponding to the process specification, whether the process has a message, what message, the format of the message, input / output parameters, the process is SparqlQuery, open API, RSS And the like, and specification items and process specification rules of these processes have been described above with reference to FIG. 1.

The process aggregator 408 collects the process specification provided from the process descriptor 406 and the URI from the URI generator 402 and combines them according to a predetermined service specification rule to form a unit service of a linked data structure. do. Here, an example of the predetermined service specification rule is the example of FIG. 1.

The unit service is input to the unit service register 410.

The unit service register 410 stores the unit service in the service storage 212, and notifies the user terminal 210 of the completion of the unit service storage through the user input / output handler 412. Here, when the user requests the storage of the unit service, the request is transmitted to the user input / output handler 412, and the user input / output handler 412 transmits the request to the unit service register 410. When the unit service is normally generated, the unit service register 410 requests to store the service in the service storage 212 and receives a storage result message from the service storage 212. At this time, the save result message is composed of messages in which the user can know whether the service is properly stored, such as "complete", "fault", and "reject". The unit service register 410 analyzes the message received from the service storage 212 and transmits the result to the user input / output handler 412 and outputs the result to the user screen.

<Service Configuration Module>

Now, the configuration and operation of the service configuration module 206 according to the preferred embodiment of the present invention will be described in detail with reference to FIG.

The service configuration module 206 configures one composite service by mashing up services selectively configured by the user through the service mashup screen 104 of the user terminal 210.

The service configuration module 206 includes a service loader 500, a service analyzer 502, a service order determinator 504, and a service aggregator. Aggregator 506, Service Descriptor 508, URI Generator 510, and Service Registration Manager 512.

The service loader 500 accepts a user's service mashup configuration request, and requests the entire information of the selected service from the service storage 212 using the service name and the like delivered together, and receives the result.

The delivered service information needs to analyze the service and analyze the service execution order determined by the user.

Therefore, the service loader 500 transmits the provided information to the service analyzer 502 to analyze whether the corresponding service is a unit service or a complex service, and if the complex service is a service, analyzes the service execution order in the corresponding service. At this time, the service order determination unit 504 determines the execution order of each service based on the execution order set in advance in the composite service and the user's selection information, and determines the service execution order so that the service order can be reflected later.

As such, the information analyzed by the service analyzer 502 and the execution order information determined by the service order determiner 504 are transmitted to the service aggregator 506. In particular, when there are a plurality of services requested by the user for mashup, the service aggregator 506 sequentially loads the services according to the user's selection.

The loaded service is delivered to the service descriptor 508, which specifies the loaded service as one composite service according to a predetermined service specification rule. In addition, since the mashed-up service must be stored in the service repository as a complex service, the mashed-up service must also be published as a service, so URI information is required. Therefore, the service aggregator 506 transfers the information loaded into the service descriptor 508 and requests the URI generator 510 to generate the URI.

The URI generator 510 generates a unique URI according to the URI generation request.

The service description and the generated URI are forwarded to a service registration manager 512.

In addition, the service registration manager 512 receives a mashup service storage request from the user screen and requests to store the mashup service in the service storage 212. It also performs the function of receiving the processing result and the updated service list and delivering it to the user screen.

<Service Execution Module>

The configuration and operation of the service execution module 208 according to the preferred embodiment of the present invention will be described in detail with reference to FIG.

The service execution module 208 performs a role of executing a mashed-up composite service and a unit service. Here, the input of the service execution module 208 is a service execution request and a service to be executed, and the output or result is a service execution result.

The service execution module 208 includes a service acceptor 600, a service parser 602, a service processor 604, a SPARQL executor 606, and an open APL executor. API executor 608, RSS executor 610, connection handler 612, result handler 614, result aggregator 616 and results It is composed of a data manager 618 and a result template provider 620.

The service acceptor 600 recognizes a service execution request through a user screen, and reads a service issued by the service configuration module 206 or a service selected through the user terminal 210 from the service storage 212. Provided to service parser 602.

The service parser 602 parses the information of the service and provides the parsed information to the service processor 604 to request analysis of the service information.

The service processor 604 analyzes a service execution order, an input for each service, an output, a data format, and the like using service information, and executes a SPARQL executor according to the data format of the service for execution. 606, an open API executor 608, and an RSS executor 610. In this case, services may have different environments that must be executed such as RSS, OpenAPI, and SPARQL queries. Therefore, the SPARQL executor 606, the open API executor 608, and the RSS executor 610 are called according to the execution environment of each service.

The SPARQL executor 606, the open APL executor 608, and the RSS executor 610 configure execution information according to the execution environment of the corresponding service, and the connection handler 612. ) Is processed in connection with external SPARQL endpoints, OpenAPI, RSS feeder, etc. to process the query and receive the result. In this case, data or services delivered as a result of query processing may have different data formats.

The connection handler 612 provides the corresponding result to the result handler 614.

The result handler 614 converts the result into a data type suitable for the linked data environment and transmits the result to the result aggregator 616.

When the service executed by the service execution module of the present invention is a complex service, since a plurality of service execution results are generated in parallel or procedurally, the result aggregator 616 is configured in the case of a complex service executed in parallel. In the case of a complex service executed by combining the service execution result of the service, and executing a procedural service, the execution result of the preceding service is transmitted as an input value of the subsequent service, and the result data manager 618 transmits the execution result of the finally executed service. To send.

The result data manager 618 receives a service execution result loaded (or collected or combined) from the result aggregator 616 and provides a result template provided by the result template provider 620 provided to increase user convenience. Combine with (Result Template) and deliver to user as execution result.

200: service mashup system
202: Validation module
204 process publishing module
206: service configuration module
208 service execution module
210: user terminal
212: service store

Claims (24)

In the service mashup system,
A validation module configured to receive a validation request message for information on service configuration through a user terminal and verify validity;
Receiving a process issuance request message including the information for the service configuration is validated, generates a URI for the information for the service configuration, and inputs the URI, information for the service configuration and information about the process And a process issuing module for receiving a process and specifying a process and issuing a unit service including the process specification. The method of claim 1,
Service repository;
The selected unit service, a unit service stored in the service repository, and one or more services that are combined with one or more services generated are selected, and a URI for a new service is generated, and the composite service is composed of the URI and selected services. And specifying and publishing a service configuration module for storing the issued composite service in the service repository.
The service mashup system, characterized in that the service repository is a unit service and a complex service. The method of claim 1,
The validation module,
Receives a validity request message for information on a service configuration including a URL and a query through the user terminal and transmits a query to a web resource corresponding to the URL,
When the processing result of the query is received from the web resource,
Determine whether the processing result is valid;
And a result of notifying the user terminal of the result. The method of claim 3,
The validation module,
A data acceptor receiving a validation request message for information on a service configuration including a URL and a query through the user terminal;
Receives a validation request message through the data acceptor, outputs a URL and a query separately, and when the processing result of the query is received, determines the validity of the information for service configuration through whether the result is valid. A validity checker for outputting the result;
A connection manager receiving a URL and a query from the validity checker, accessing a web resource corresponding to the URL, providing the query, and receiving a processing result of the query from the web resource and transmitting the result to the validity checker;
Service mashup system comprising a result handler for receiving the validity check by the validity checker provided to the user terminal and the process issuing module. The method of claim 3,
The process issuance module,
When a unit service issuance is requested through the user terminal,
Create a URI,
The generated URI,
A process is specified according to a predefined process specification rule based on a URL and a query determined to be valid by the validation module and information about a process input through the user terminal, and a unit service including the process specification is issued. Service mashup system, characterized in that. The method of claim 5,
The process issuance module,
A data acceptor for receiving a URL, a query determined by the validity checking module, and information about a process input from a user terminal;
A URI generator for generating a URI;
A data parser for parsing URLs and queries from the data acceptor and information about processes entered from user terminals;
A process descriptor for specifying the parsed URL, the information about the query and the process according to a predefined process specification rule;
A process aggregator receiving the URI and the specification of the process and combining the URI and the process to generate a unit service;
And a unit service register for receiving the unit service and storing the unit service in a service repository. The method of claim 6,
The process issuance module,
And a user input / output handler for handling input / output data with the user terminal. The method of claim 2,
The service configuration module,
A service loader for loading one or more services selected by a user from among unit services issued by the process publishing module and unit services and composite services stored in the service repository;
A service analyzer analyzing one or more services loaded by the service loader;
A service order determiner configured to determine an execution order of the one or more services according to a user's selection and a service execution order in a composite service;
A service aggregator for loading the at least one service in an execution order;
A service descriptor for specifying one or more services loaded on the service aggregator according to a predetermined service specification rule;
A URI generator for generating a URI for a new service consisting of the one or more composite services;
And a service registration manager for issuing a specification for the one or more services and a URI for the new composite service as a new composite service and registering it in a service repository. The method of claim 2,
According to the execution request for a service issued by the service configuration module or a service registered in the service repository,
And a service execution module for parsing the service, executing the parsed service, and providing the execution result to the user terminal. 10. The method of claim 9,
The service execution module,
A service acceptor for receiving a unit or complex service from the service repository or the service configuration module;
A service parser for parsing a unit or composite service input by the service acceptor;
A service processor for analyzing a data type in the case of a unit service, and analyzing the data type for each unit service according to an execution order of a unit service in a complex service, and outputting the data type according to the analyzed data type;
A plurality of executors for receiving and executing unit services according to data types;
A connection handler connecting an external web resource and the plurality of executors to execute the plurality of executors;
A result aggregator that receives and loads the processing results from the plurality of executors;
And a result data manager configured to provide the loaded result to a user terminal. The method of claim 10,
The service execution module,
And a result handler which receives the processing results from the plurality of executors, converts the data into a data format according to the linked data environment, and sends the result handler to the result aggregator. The method of claim 10,
The service execution module,
It further comprises a result template providing unit for providing a result template stored in advance;
And the result data manager combines the result template from the result template providing unit and the loaded result to the user terminal. The method of claim 10,
The plurality of executors,
RSS Launcher,
Open API launcher,
A service mashup system characterized by being a SPARQL launcher. In the service mashup method,
A validity checking step of receiving a validity request message for information on a service configuration through a user terminal to verify validity;
Receiving a process issuance request message including the information for the service configuration is validated, generates a URI for the information for the service configuration, and inputs the URI, information for the service configuration and information about the process And a process issuing step of specifying a process and issuing a unit service including the process specification. The method of claim 14,
The selected unit service and the unit service stored in the service repository and the one or more services are selected from a combination of some of the composite services generated, generate a URI for a new service, and specify the composite service with the URI and the information of the selected services And issuing a service, and configuring the service to store the issued composite service in the service repository. The method of claim 14,
The validation step,
Receiving a validity request message for information on a service configuration including a URL and a query through the user terminal and transmitting a query to a web resource corresponding to the URL;
When the processing result of the query is received from the web resource,
Determine whether the processing result is valid;
And notifying the user terminal of the result of the service mashup method. The method of claim 16,
The validation step,
Receiving, by a data acceptor, a validity request message for information on a service configuration including a URL and a query through the user terminal;
The validity checker receives the validation request message through the data acceptor, separates the URL from the query, and outputs the result. When the processing result of the query is received, the validity checker determines whether the result is valid or not. Determining validity and outputting the result;
The connection manager receives a URL and a query from the validity checker, accesses a web resource corresponding to the URL, provides the query, receives a processing result of the query from the web resource, and transmits the result to the validity checker. step;
And a result handler receiving the validity determination result from the validity checker and providing the result to the user terminal and the process issuing module. The method of claim 16,
The process issuance step,
Generating a URI when a unit service issuance is requested through a user terminal;
The generated URI, the URL determined to be valid by the validation module, the query, and the information about the process input through the user terminal are specified in accordance with a predefined process specification rule, and the process specification is included. Issuing a unit service to the; service mashup method comprising the. The method of claim 18,
The process issuance step,
Receiving a URL, a query determined to be valid, and information on a process input from a user terminal;
Generating a URI;
Parsing information about the URL, a query, and a process input from a user terminal;
Specifying information about the parsed URL, the query, and the process according to a predefined process specification rule;
Generating a unit service by combining the URI and the specification of the process;
Receiving the unit service and storing the received service in a service repository. 16. The method of claim 15,
The service configuration step,
Loading at least one service selected by a user from among unit services issued in the process issuing step and unit services and composite services stored in the service repository;
Analyzing the loaded one or more services;
Determining an execution order of the one or more services according to a user's selection and a service execution order in a composite service;
Loading the at least one service in an execution order;
Specifying the loaded at least one service according to a predetermined service specification rule;
Generating a URI for a new service consisting of the one or more composite services;
Issuing a specification for the one or more services and a URI for the new composite service as a new composite service and registering it in a service repository. 16. The method of claim 15,
According to the execution request for a service issued by the service configuration step or a service registered in the service repository,
And a service execution step of parsing the service, executing the parsed service, and providing the execution result to the user terminal. The method of claim 21,
The service execution step,
A first step of receiving a unit or complex service from the service repository or the service configuration module;
Parsing the received unit or composite service;
A third step of analyzing a data type in the case of a unit service, and analyzing a data type for each unit service according to an execution order of a unit service in a complex service, and outputting the data type according to the analyzed data type;
A fourth step of executing the unit service through an executor corresponding to the data type for each unit service;
A fifth step of receiving and loading the processing result for each unit service;
And a sixth step of providing the loaded result to the user terminal. The method of claim 22,
The service execution step,
And receiving the processing result for each unit service according to the execution of the fourth step, changing the data result according to the linked data environment, and entering the fifth step to load the changed processing result for each unit service. Service mashup method characterized in that. The method of claim 22,
The sixth step,
The service mashup method, characterized in that to provide to the user terminal by combining the loaded result in the result template stored in advance.

Images