KR20110067787A - Framework apparatus based on domain object interface - Google Patents

Abstract

PURPOSE: A framework apparatus based on domain object interface is provided to enable a user to recognize immediately the change of the web service type by providing a browser capable of searching and executing a service. CONSTITUTION: A data model layer performs the mapping of the data stored in database and the domain objects of the executing context, and then provides data storage and recovery service. A service model layer extracts a executable method from metadata of the executing code wherein a business logic is implemented, and provides the method as a service. A service executing layer determines the policy and strategy for the processing mode of service executing request. A service view layer provides a new service through the combination of function groups for the service.

Description

Framework device based on domain object interface {FRAMEWORK APPARATUS BASED ON DOMAIN OBJECT INTERFACE}

The present invention relates to a framework based on a domain object interface. More specifically, the present invention relates to a web service registration, automation of distribution and service exposure in search and development, business logic and domain object model mapping, dynamic service recombination, and web. The present invention relates to a session device for providing transaction and encryption between services and a framework device based on a domain object interface suitable for integration with a legacy web.

As is well known, distributed environment technologies have evolved into proprietary models for location transparency and interoperability to users.

However, this distributed environment technology is difficult to create an environment that is not dependent on a specific development environment, and distributed object users have to define a separate interface for searching by platform and deliver a message about an object through a broker. Domain-specific services such as session management and security issues have to be designed and implemented in their own way.

Accordingly, in order to solve this problem, a web service technology has been developed. The web service technology enables the processing of heterogeneous messages, the purification and reuse of existing services through XML-based information exchange.

However, the existing XML-based web service technology requires existing source changes to apply existing business logic, and iterates on defining, inputting, modifying, and deleting a domain object model for use in business logic. The problem is that you have to write code or use a separate external domain object processing framework.

In view of the above, new session-related standards for storing information and processing transactions between web services have been proposed, but these new session-related standards use an intermediate repository or legacy web services for exchanging information with legacy web services. There is a problem that a developer must generate a SOAP message.

According to an aspect, the present invention provides a data model layer that maps data stored in a database to domain objects in an execution context, and provides a service for storing and restoring data, in a metadata of executable code in which business logic is implemented. Functions for the service model layer that extracts executable methods and provides them as services, the service execution layer that determines policies and strategies for how to handle incoming service execution requests, and functions for previously written services. The combination of groups provides a framework object based on a domain object interface including a service view layer for providing a new service.

Here, the service execution layer includes a cache manager that caches an instance of the service used, a session manager that manages the storage and restoration of sessions between web service calls, and services that a particular web service instance must provide by default. And a service manager for managing the reuse of the generated service instance.

According to the present invention, a user can immediately recognize a change in the type of web service provided at runtime by providing a browser that can search and execute a service, and the HTTP-based legacy web environment and the new web service technology are not disconnected. HTTP-based request response can be maintained.

In addition, the present invention can be used in various heterogeneous business logics by automating the data modeling and the persistence operations of repeated input, search, modification, and deletion, and the performance of the ER model and the extensibility of XML when generating the physical model of the domain object. Can be obtained.

The present invention can be implemented without significant difference from the legacy web development methodology by introducing a service browser that reduces the time cost for web service development and facilitates the web service registration, modification, and removal for smooth integration with the legacy web environment. Seamless communication between heterogeneous systems can be realized by automating the process of domain object modeling and its use.

In addition, the present invention provides a session function in order to solve the problem of information retention and security between service method invocations, through which the information in the communication with the existing legacy web environment without the secondary storage outside the framework in the Web service requiring transactions It can preserve and automate mutual business logic invocation and information transfer and transmission.

In addition, the present invention proposes a meta-domain object model for service users to access domain objects in a fast and optimized manner, and provides an automated framework for automatically creating a physical domain object model after declaration, and between service calls. The domain object is expressed based on XML, and the development period of the protocol can be shortened by using the declaration of the domain object according to the data transfer protocol between domains.

Hereinafter, with reference to the accompanying drawings will be described in detail a preferred embodiment of the present invention.

In addition, in the following description of the present invention, if it is determined that a detailed description of a known function or configuration may unnecessarily obscure the subject matter of the present invention, the detailed description thereof will be omitted. In addition, terms to be described below are terms defined in consideration of functions in the present invention, which may be changed according to intention or custom of a user, an operator, or the like. Therefore, the definition should be made based on the technical idea described throughout this specification.

First, the present invention proposes a meta service model for facilitating registration and retrieval of web services, and provides a web service registry that can dynamically add, modify, and delete web services. To improve performance, domain objects containing metamodels reside in main memory and periodically store themselves in the persistence area to minimize data loss due to service failure. At this time, since the service stored in the metamodel domain object is verified at the time when it resides in the main memory, only the executable service can be seen at execution time, thereby increasing the reliability of the system.

In addition, the present invention supports dynamic service combinations to reuse existing web services. For this purpose, a combination in the service view layer first combines a group of functions that bind individual services, while a combination in a service execution layer. Are combined by component combination, AOP, and dynamic proxy generation. Single or combined operations are grouped together to form a unit service. Externally, web services can be executed through web browsers and SOAP-based proxies without distinguishing between local and remote. Internally, the local service executes by sending a launch message directly to the service instance, and the remote service executes the framework by creating a SOAP-based proxy. Here, the framework partially supports sessions and provides a methodology for integrating with existing legacy webs to implement web services.

The present invention also uses an ER-based data model as the data model of domain objects used in business logic to automate the storage and retrieval of domain models. The declared data model automatically creates tables and views in the RDBMS and creates stored procedures to manipulate them. Persistence operations in business logic are either through auto-generated stored procedures or through stored procedures declared by the service provider. Thus, service providers can easily and quickly access persistence areas in business logic with minimal declarations and API usage.

1 is a block diagram of a framework apparatus based on a domain object interface according to the present invention, which includes a data model layer (DML), a service model layer (SML), and a service execution layer. Service execution layer (SEL) and service view layer (SVL), and the like. The service execution layer () includes a cache manager (), a session manager (), a service injector (), and a service. Manager () and the like.

Referring to FIG. 1, the data model layer (A) maps data stored in a database to domain objects in an execution context, and provides a service for storing and restoring data. The data model layer () is presented to data and service users used in business logic. A layer that provides services to handle modeling for the view to be performed. Most of the work is done through the domain object interface (DOI) inside the data model layer. Here, the domain object interface provides an interface for loading, retrieving, modifying, and storing XML-based domain objects.

Accordingly, the service provider may use the domain object interface to perform domain object configuration for the model and view for the service and generate a service domain model of the business logic.

Next, the service model layer () extracts an executable method from the metadata of the executable code where the business logic is implemented, and provides the extracted method as a service, which is a remote web service description language (WSDL). language) accesses the document and verifies whether the service is available and adds it to the runtime repository only if the verification results are available. In addition, the service model layer () obtains prototypes of business logic from local business logic components and generates WSDL objects based on them. At this point, the service instance is guaranteed to run because the web service combination and execution architecture (framework) add only the verified service to the runtime repository.

In addition, the service execution layer () determines a policy and strategy for how to handle a service execution request when it comes in. Optionally include synchronous / asynchronous execution, session persistence, cache policy, and instance acquisition method. . In addition, the service execution layer () generates a dynamic proxy that adds execution code to a service to be executed before and after as a service instance, and the dynamic proxy may be generated using an AOP method. In addition, the service execution layer () delivers the execution message directly to the service instance for the local service and executes the SOAP-based proxy by the framework for the remote service.

To this end, the service execution layer () includes a cache manager (), session manager (), service injector () and service manager () and the like.

First, the cache manager () caches the instance for the service used, and creating an instance per call can degrade service performance because certain service operations can be called repeatedly in a short time. For this reason, the cache manager caches instances for a relatively long time for services that are used frequently.

In addition, the session manager manages the storage and restoration of sessions between web service invocations, for example, matching each user request with the key of the session created when the user first connects to the web server, and passing parameters between web services in a transactional relationship. For the purpose of automatically saving and restoring data for the purpose, a session concept may be required in a specific combination of services.The data in the domain object needs to be selected at the time of service declaration and the session can be selected. In this case, the session value is retrieved from the session store before the call, and the new value in the domain object is stored back in the session store after the service is called. Here, Session Manager uses HTTP-based sessions between Web service executions for compatibility with legacy web applications.

Next, the service injector () performs injection for the services that a particular web service instance should provide by default, enabling dynamic combinations of services in the service execution layer () and injecting services by default. Is a session manager, which enables session handling on service instances. In addition, the service injector () injects another service immediately before or immediately after the service execution by adding another service immediately before or after the code execution of the service, that is, by setting up aspect-oriented programming (AOP). It creates a new executable code. For example, in the case of Java, dynamic proxy is generated and processed. In the case of C, C ++, and Assembly, the function according to the call stack is called first.

The service manager () manages reuse of the generated service instance.

Meanwhile, the service view layer () provides a new service through a combination of function groups for a previously created service. A domain object receives an XML-based message and processes it. Generally, a web service provider uses a service execution layer (). The result is then processed into a graphical user interface (GUI), which uses XSLT to create the desired view model.

The service view layer also provides a web service browsing service that can be used by a service provider and a service that can execute a browsed operation.

Next, the combination in the business logic layer and the combination in the user view layer executed in accordance with the present invention will be described.

2 is a class diagram illustrating the relationship between two statically defined service instances and dynamically generated proxies.

3 is an exemplary view showing a result of executing a dynamic proxy in which a static service instance is combined.

Referring to FIG. 3, since the operations are intact when combining static service instances, the service provider must process execution for the service instance in two contexts. This is not a problem when testing service performance locally, but because it creates two network connections when testing service performance remotely, even if the performance of individual operations is high, it can outperform dynamically generated dynamic proxies depending on network conditions. This can be lowered.

4 is a declaration of a class for creating a dynamic service class.

Referring to FIG. 4, AbCodeDelegator has an abstract method called appendCode (). If the code byte order is specified by inheriting the abstract method, a class is generated at run time to generate an object through a dynamic proxy.

Here, the instructionList field of the AbCodeDelegate class contains the order of execution code. Since the execution code is associated with a specific operation, it has a Factory class to associate the execution method with a specific method. And, to store constants used in executable code, we declare Constant Pool, MethodGen represents one method, and several methods are stored in one ClassGen.

5 is an exemplary screen diagram illustrating an example of dynamically generating a class. In the appendCode () method, the BCEL libraries are used in byte code order.

6 is an exemplary view showing a dynamically generated byte code, and the generated code is created in the same manner as the contents created by appendCode (). At this time, the generated byte code uses the default instruction set of JRE.

FIG. 7 is an example of a screen showing that a dynamically added method is executed after loading a generated class with a dynamic proxy.

FIG. 8 illustrates an example of a screen showing an execution result of a dynamic service instance. As shown in FIG. 8, a parameter is passed to a dynamically generated service instance to obtain a service result identical to an intention of generating in appendCode ().

FIG. 9 is an exemplary screen diagram showing an example of code for combining in a user view hierarchy. After the user view is loaded, the combination is attempted to show different combined results according to the results of the view screen. Can be modified via dynamic function loading.

That is, services according to the present invention may be dynamically combined through a service execution layer and a service view layer.

FIG. 10 is a diagram illustrating a combination algorithm in a service execution layer. A dynamic proxy including execution code for a service to be executed before and after in a service execution layer is generated as a service instance and provided to the service instance. In this case, the dynamic proxy may be generated using the AOP method.

FIG. 11 is a diagram illustrating a combination algorithm in a service view. In the service view layer, a service group is created by combining functions based on a functional language. Here, the service prototype in the service metamodel layer has no declaration of the function group for success and failure, but the function group is dynamically created in the service view layer using the function as a first-class object. can do. For each service instance, the function group for success failure acts as the service execution instance. Alternatively, you can create a group of functions by accessing the configuration for a combination at runtime.

As described above, the method of providing a dynamic proxy generated in the service execution layer to the service instance has high performance, is recognized as a single service when accessed from the service view layer, and is easy to detect errors, while being complex to use. And use more resources. Examples of this approach can be found in perspective-oriented programming or intermediate language transformations, which the framework supports using this approach.

Unlike the above, the method used in the service view layer is somewhat lower than the dynamic proxy and has a disadvantage in that error detection is difficult because the services are recognized as multiple services, while being easy to understand and use less resources. Reflection acquires metadata and generates WSDL, so you can easily create and run web services from existing components. This process does not require any additional tools, and can be reused without changing existing infrastructure. In addition, it supports sessions to maintain context during service execution and can overload operations with the same name in the same service. In addition, both remote and local services can be called, and because local service endpoints are created automatically, domain developers do not have to consider service endpoints at all.

The inventors of the present invention carried out the implementation and experiment in the following implementation and experimental environment and the results are as follows.

CPU: AMD Athlon 64 bit Dual Core 2.0 GHZ

OS: Windows XP Professional

Language: Java (JDK 1.6.0 Update 10 Version)

In this implementation and experiment, we used HttpClient 4.0 Beta 1 version as a request of a specific service and BCEL 5.2 was used to dynamically create dynamic proxy and service instance at runtime. We also used the Java API to dynamically generate static proxies at runtime, and used the prototype.js library to test the view layer combination. In addition, the performance measure measures the average time taken to find the domain process model and performs a total of 100,000 requests at 100 threads / sec.

[Experiment result]

12 is a graph of performance evaluation results for retrieving and initializing a combined service in the business logic layer.

Referring to FIG. 12, the time taken to create a domain object by using various ORM methods such as JDBC, iBatis, and Hibernate for a service instance by accessing the same service registry is described. Type of persistence operation used in a service instance Regardless, we can see that the service instance is created in about 0.03 milliseconds. That is, according to the present invention, the execution time does not take any time for the combination because the combination of service operations is completed before the execution time and a new class is generated.

That is, the combination in the user view hierarchy always terminates at constant time. The code for a group of functions enclosing a service operation will be read by the parser of the processing programming language and then create a single function context, after which the service operation can be processed. This process takes place only once, and the generated function group code continues to be used at run time, so as with any combination in the business logic layer, it does not take any time to execute.

[Implementation result]

FIG. 13 shows a web service explorer screen provided by default. The web service explorer displays all services of the WSDL repository separately from remote and local through the DOIMetaService service of the meta service group. Here, since the service list is returned in XML format, when providing it to the service user, the user interface of the desired type is created by using the XSLT processor service provided by the view layer. Therefore, the web service provider can select and execute the service to be distributed to the outside through the template provided by default.

14 illustrates an interface screen listing operations in a specific service. When an operation has a parameter, an input form may be provided and a service provider may execute a service operation. If the service instance is a service instance created based on the framework-aware class AbDOIService, it must include the getSessionId () and isWarmed () methods, which make the connection to the DBMS and the objects involved in the request, response, and session available. .

FIG. 15 is an exemplary view showing a SOAP message returned as a result of executing a remote service. In the case of a remote service, the same form as that of FIG. 15 is generated, but the process is different. To do this, the remote service extracts the operation from the WSDL document to construct a context and send a SOAP request.

FIG. 16 is a diagram illustrating a web service proxy generated by referring to a WSDL document in a heterogeneous environment of the .NET framework. FIG. 16 illustrates a result of requesting and processing a SOAP message through a technique of the present invention implemented using Java. Indicates.

In the above description has been described by presenting a preferred embodiment of the present invention, but the present invention is not necessarily limited to this, and those skilled in the art to which the present invention pertains within a range without departing from the technical spirit of the present invention It will be readily appreciated that branch substitutions, modifications and variations are possible.

1 is a block diagram of a framework apparatus based on a domain object interface according to the present invention;

2 is a class diagram showing the relationship between two statically defined service instances and a dynamically generated proxy;

3 shows the result of running a dynamic proxy combining static service instances,

4 is a declaration of a class for generating a dynamic service class,

5 is an exemplary screen illustrating an example of dynamically generating a class;

6 is a screen example showing a dynamically generated byte code,

7 is a screen example showing loading a generated class with a dynamic proxy and executing a dynamically added method.

8 is an exemplary view showing a result of executing a dynamic service instance.

9 illustrates an example of a code for a combination in a user view hierarchy.

10 illustrates an example of a combination algorithm in a service execution layer.

11 illustrates an example of a combination algorithm in a service view.

12 is a graph of performance evaluation results for retrieving and initializing a combined service in a business logic layer,

13 is a web service explorer screen provided by default;

14 is an interface screen listing operations in a particular service;

15 shows an example of a SOAP message returned as a result of executing a remote service.

FIG. 16 is a screen example showing generating a web service proxy by referring to a WSDL document in a heterogeneous environment of the .NET framework. FIG.

Claims (19)

A data model layer that maps data stored in the database to domain objects in the execution context and provides services for data storage and restoration; A service model layer that extracts executable methods from the metadata of executable code that implements business logic, and provides these extracted methods as services; A service execution layer that determines policies and strategies on how to handle incoming service execution requests; Service view layer that provides a new service through a combination of function groups for the previously created service Domain device interface based framework device comprising a. The method of claim 1, The mapping is, Through the domain object interface (DOI) The framework apparatus based on the domain object interface, characterized in that. The method of claim 2, The domain object interface, Interface to XML-based Domain Objects The framework object based on the domain object interface, characterized in that. The method of claim 3, wherein The interface is, At least one of loading, searching, modifying, and storing the domain object. The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The method is Extracted using reflection The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The method is Provided as a single Web method or as a combined service The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service model layer, Access a remote web services description language (WSDL) document to verify that the service is available, and store the service in the runtime repository when it is available. The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service model layer, Prototype business logic from business logic components for a local service and then create a WSDL object based on it. The framework apparatus based on the domain object interface, characterized in that. The method of claim 8, The WSDL object is Generated at the time of framework initialization The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service execution layer, Runs by passing a launch message directly to the service instance for the local service, and the framework generates and executes a SOAP based proxy for the remote service. The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service execution layer, Optionally include at least one of synchronous / asynchronous execution, session persistence, cache policy, and instance acquisition. The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service execution layer, Create a dynamic proxy as a service instance that adds execution code for the service to run before and after The framework apparatus based on the domain object interface, characterized in that. 13. The method of claim 12, The dynamic proxy, Created using AOP method The framework apparatus based on the domain object interface, characterized in that. The method of claim 1, The service execution layer, A cache manager that caches instances for the services used, A session manager that manages saving and restoring sessions between Web service calls; A service injector that performs injection for services that a particular web service instance must provide by default, Service Manager, which manages reuse for created service instances Domain object interface-based framework device comprising a. The method of claim 14, The session manager, For data that needs to maintain state among the data in the domain object, select at service declaration time. The framework apparatus based on the domain object interface, characterized in that. The method of claim 14, The session manager, Use HTTP-based sessions between Web service executions for compatibility with legacy web applications. The framework apparatus based on the domain object interface, characterized in that. The method of claim 14, The service injector, AOP configuration allows you to inject other services immediately before or after service execution to generate new executable code. The framework apparatus based on the domain object interface, characterized in that. The method of claim 14, The service injector, To provide a dynamic combination of services in the service execution layer The framework apparatus based on the domain object interface, characterized in that. The method of claim 14, The service view layer, Domain Objects Receive XML-Based Messages The framework apparatus based on the domain object interface, characterized in that.

Images