KR20110077578A - Method of executing ria application and method of supporting multi-version ria component - Google Patents

Abstract

PURPOSE: A RIA application execution method and a RIA component multi-version support method are provided to use two or more versions of component embodiment bodies for a component type according to a business domain or a form. CONSTITUTION: RIA(Rich Internet Application) runtime acquires a component storage designated by a RIA application or a RIA form(S410). Using the acquired component storage, the RIA runtime selects a component embodiment body class according to the RIA application or the RIA form(S420). Using the selected component embodiment body class, the RIA runtime executes the RIA application(S430).

Description

How to execute RIA application and how to support RIA component {Method of executing RIA application and method of supporting multi-version RIA component}

The present invention relates to a Rich Internet Application (RIA), and to a technology for supporting multiple versions of RIA components that can prevent unnecessary system migration by allowing different systems and versions of business systems running on a single client computer.

HTML provides an object tag to use externally defined components in a web page. In order to use an object tag, information about an execution code and a version must be repeatedly described for a component to be used. In addition, the components defined in this way have a structure that is difficult to integrate into organic units in an application since instances are always loaded and created in independent module units.

RIA (Rich Internet Application) is a web application that implements the functions and features of traditional desktop applications. It is used as a solution to replace web browser based applications that could not be manipulated. In particular, RIA is also called X Internet, and RIA provides a dynamic and convenient customer-oriented web page that has not been seen on the web through a single interface.

RIA applications provide a component-based programming model. In particular, the components that implement business logic with the core in the user interface are different versions of components for commonly required UIControls such as buttons, edits, combo boxes, etc. In general, one component has a very high reuse rate in one form or business domain, which is a general characteristic of Enterprise RIA.

In general, a RIA component is given a fixed name and an implementation is created with the same name as the given name.

That is, a component that performs a specific function is given a unique name to distinguish it from other components, and the RIA runtime already knows about all kinds of necessary components, and each component has a predetermined implementation. If the component and implementation name are the same, confusion is minimized during development and maintenance, so it is easy to implement and manage.

1 is a diagram illustrating a relationship between a RIA component and a component implementation according to the prior art.

Referring to FIG. 1, it can be seen that the RIA runtime 110 allows only one implementation 130 per RIA component 120.

At this time, the RIA runtime 110 is software that provides an environment for executing the RIA application on the client computer and reads and executes the RIA application source code. The RIA component 120 runs on the RIA runtime 110 to provide a user interface to support user interaction, or to be independently deployed and executed to be highly reusable to perform specific business logic that is invisible to the user. It is possible software developed.

Implementation 130 is a collection of executable programs implemented using a computer language to be executable on a computer for a subject providing a particular function designated as a RIA component.

If the component and the implementation correspond to 1: 1, there is no problem when the client computer connects to only one work system (implemented as a RIA application). However, when one client computer needs to access two or more work systems each implemented as an RIA application, a work system implemented as an RIA application when the component version used in the work system and the component version installed in the client computer do not match. Will not work properly. Therefore, each work system must always match the version of the component used in the work system in order to match the component version to be installed on all accessible client computers. This means that the work system that has been developed and used without any problems should change part or all of the work system due to other work systems that are developed later. It poses a threat to stability.

The problem arises due to the limitation that the version of the RIA component installed on the client computer of a user who needs to use two or more server systems at the same time must be a single version.

i) The development of a new server system requires modification of the application of the existing server system.

ii) In order to circumvent the change of the existing server system, even though there is a new version of the RIA component with better function, the new system should be developed with the previous version of the RIA component.

iii) The new RIA component cannot be upgraded due to the change of server system.

This allows for the use of two or more different versions of component implementations for a component type, depending on the business domain or form, so that business systems running on a single client computer may have different components and There is an urgent need for new RIA component multi-version support technologies that make it possible to use versions and avoid unnecessary migration.

An object of the present invention for solving the above problems is to enable the use of multiple component implementations with different versions for each RIA application or RIA form for the RIA component referenced by the name specified in the RIA platform.

In addition, the present invention prevents unnecessary efforts to match RIA component versions between unrelated business systems in order to avoid version conflicts of RIA components installed on client computers when a user uses two or more RIA applications. For the purpose of

RIA application execution method according to the present invention for achieving the above object is specified by any one of the RIA application (application) and RIA form (form), a component implementation class that implements the RIA component type and the RIA component type Obtaining a component store for mapping and storing the data; Selecting the component implementation class corresponding to the RIA component defined as the RIA component type for each RIA application or the RIA form using the component repository; And executing the RIA application using the selected component implementation class.

In this case, the selected component implementation class may be applied to the corresponding RIA component in the scope of the RIA application or RIA form that specifies the component repository including the selected component implementation class.

In this case, when the RIA form does not specify the component store, a component store corresponding to a RIA application or a higher RIA form including the RIA form may be used for the RIA component used in the RIA form. have.

In this case, the component store may include an address of a component implementation to be used and a name of the component implementation class included in the component implementation for each RIA component type.

In this case, the acquiring of the component store may include downloading the RIA application to obtain an address of the component store and downloading the component store from the address of the component store.

In this case, executing the RIA application may include loading the selected component implementation class into a memory, binding the RIA component type, and generating and returning an instance of the component implementation by the RIA runtime. .

In addition, the method for supporting multiple versions of the RIA component according to the present invention, the method comprising: mapping the RIA component type and the component implementation class implementing the RIA component type to store in the component repository; And providing the component repository designated by one of a RIA application and a RIA form to a RIA runtime of the client computer at the request of a client computer.

In this case, the component store may be used to create an instance of the corresponding RIA component within the scope of the RIA application or RIA form that specifies the component store.

According to the present invention, two or more different versions of component implementations (implementation classes) can be used for one component type per business domain or form, so that business systems running on a single client computer It is possible to use different components and versions.

In addition, the present invention can use two or more different versions of the component implementation of the RIA component, it is possible to prevent unnecessary system migration (migration).

In addition, the present invention can use a multi-component implementation with different versions in RIA application unit for the RIA component referred to by the name specified in the RIA platform, and different component implementations for each form in the same business domain to the same component It can be used as a name to avoid version conflicts with RIA components installed on client computers.

The present invention will now be described in detail with reference to the accompanying drawings. Here, the repeated description, well-known functions and configurations that may unnecessarily obscure the subject matter of the present invention, and detailed description of the configuration will be omitted. Embodiments of the present invention are provided to more completely describe the present invention to those skilled in the art. Accordingly, the shape and size of elements in the drawings may be exaggerated for clarity.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

2 is a diagram illustrating a relationship between an RIA runtime, an RIA application, and an RIA form and a component repository according to an exemplary embodiment of the present invention.

Referring to FIG. 2, the RIA runtime 210 may include a plurality of RIA applications 220.

The RIA runtime 210 is software that provides an environment for executing the RIA application 220 and reads and executes source code of the RIA application 220.

RIA application 220 may include zero or more RIA forms 230.

The present invention provides a mechanism for specifying multiple implementations (implementation classes) for a single RIA component name, so that multiple implementations (implementation classes) can be used simultaneously with one RIA component name in the RIA runtime 210. Make sure At this time, the RIA component name is defined as a type, and has a structure in which the component name and the implementation are connected through the type.

As a result, a component type may be regarded as a reference name of a data typed RIA component so that the RIA component may be uniquely identified and a plurality of instances may be generated from one binary code.

At this time, the RIA component is executed in the RIA runtime 210 to provide a user interface to support interaction with the user, or independently to be highly reusable to perform specific business logic that is not visible to the user. Software developed to be distributed and executable.

For example, the RIA component may be a control used to display data on a screen, provide interaction with a user, and manage and provide data as a result of interaction with the user.

The RIA application 220 represents an independent unit capable of operating a business system for each business domain, such as a human resources system, an accounting system, etc. The RIA form 230 may be a distribution unit for processing a business transaction in the business domain. For example, the present invention can be implemented with TypeDef tag technology in XPLATFORM, one of the applicant's products.

RIA application 220 designates one component repository 240. That is, in the present invention, each RIA application may designate one component repository.

The RIA form 230 is a distribution and execution unit that generates a presentation screen using controls and provides interaction with a user so that the RIA application 220 can perform a logical transaction.

RIA form 230 also specifies one component repository 250. That is, in the present invention, each of the RIA forms may designate one component repository. However, each RIA form may not specify a component repository. In this case, RIA forms that do not specify a component repository can use the parent RIA form or the component repository specified by the RIA application.

In other words, the RIA application defines a component type applied to the entire business domain, and the RIA form defines a component type applied to the corresponding form and subforms.

The RIA runtime 210 consequently manages a plurality of component repositories 240, 250, thereby enabling the use of multiple component implementations with one component type within the same business domain.

A component implementation is a collection of executable programs implemented using a computer language that can be executed on a computer for an object providing a particular function specified by the component type. In particular, the component implementation may be viewed as a set corresponding to a distribution unit of component implementation classes, and may be provided in the form of a DLL (Dynamic Link Library).

The component store may store the relationship between the component type and the component implementation so that the component implementation may be referred to as a component type, and information of a distribution server capable of downloading the component implementation.

Each component repository contains one or more component implementations. In the example of FIG. 2, component store 240 includes information of two component implementations 243 and 244, where component type 241 is class 245 of component implementation 243. The component type 242 corresponds to the class 246 of the component implementation 243.

Component implementations each contain one or more class implementations.

That is, the component repository can be regarded as specifying a class name to be mapped with a component type among component classes, URL of a component implementation to be used, and several classes existing in the implementation.

As can be seen by comparing FIG. 2 with FIG. 1, the present invention uses a RIA component name as a type, manages connection information between a type and an implementation, and uses a component type in an application, thereby loosely connecting the application and the component. To have.

Hereinafter, the multi-version support process of the RIA component of the present invention will be described.

1) Package the implementation class implemented by the RIA component name by the implementation unit and register it in the distribution server.

2) Register the component name in the component repository by mapping the component name with the implementation class given in 1).

3) In RIA applications and RIA forms, you specify the component repository to use.

4) The RIA runtime downloads and analyzes the RIA application to determine the URL of the component repository.

5) The RIA runtime reads the component repository from the URL in 4).

6) Check and download the component implementation URL specified in the component repository and install it on the client.

7) Load the component implementation into memory and bind it to the type specified in the component repository.

8) When requesting to create a control in the RIA form, the RIA runtime creates and returns an instance of the component implementation mapped to the specified type.

Steps 4) to 7) above may be viewed as RIA component loading processes performed by the RIA runtime when the RIA application is executed.

As a result, in the present invention, a RIA application uses a type without considering an implementation during development, and uses a component that is dynamically bound by using a component implementation provided by the RIA runtime.

3 is a diagram illustrating a case of designating a component store for each RIA form using the component store.

Referring to FIG. 3, the RIA runtime 310 includes two RIA forms 320 and 330.

RIA form 320 specifies component store 340, and RIA form 330 specifies component store 350. As described above, according to the present invention, RIA component multi-version can be supported by designating a component repository for each RIA application or RIA form.

RIA form 320 includes controls 321, 322, 323, 324, 325, 326, 327. RIA form 330 includes controls 331, 332, 333, 334, 335, 336, 337.

RIA forms 320 and 330 each specify controls using a component type to compose a presentation.

All controls used in RIA form 320 and RIA form 330 correspond to one of five component types, Type 1 through Type 5, respectively.

The component stores 340 and 350 designate a class to be mapped with a component type among URLs of the component implementation to be used and classes existing in the implementation, for each of five component types of types 1 to 5.

After loading the RIA forms 320 and 330, the RIA runtime 310 determines the component type specified by the control, finds a component implementation from the component store designated by the RIA form, creates an instance, and returns the result to the control.

Implementation 360 includes three implementation classes 361, 362, 363. Implementation 370 includes four implementation classes 371, 372, 373, 374. Implementation 380 includes two implementation classes 381 and 382.

Component store 340 uses two implementations 360, 370, and component store 350 uses three implementations 360, 370, 380.

Component store 340 maps implementation class 361 of implementation 360 to type 1 341. Component store 340 maps implementation class 363 of implementation 360 to type 2 342. Component store 340 maps implementation class 371 of implementation 370 to type 343. Component store 340 maps implementation class 373 of implementation 370 to type 4 344. Component store 340 maps implementation class 374 of implementation 370 to type 5 342.

Component store 350 maps implementation class 361 of implementation 360 to type 1 351. Component store 350 maps implementation class 363 of implementation 360 to type 2 352. Component store 350 maps implementation class 372 of implementation 370 to type 353. Component store 350 maps implementation class 381 of implementation 380 to type 4 354. Component store 350 maps implementation class 382 of implementation 380 to type 5 352.

As a result, implementation class 361 is used for both RIA form 320 and RIA form 330 for RIA component type 1, and implementation class 363 for both RIA form 320 and RIA form 330 for RIA component type 2. ) Is used.

However, for RIA component type 3, implementation class 371 is used in RIA form 320 and implementation class 372 is used in RIA form 330. In this case, the RIA form 320 and the RIA form 330 may be considered to use different implementation classes in the same implementation for the same component type.

For RIA component type 4, implementation class 373 is used in RIA form 320 and implementation class 381 is used in RIA form 330. In this case, the RIA form 320 and the RIA form 330 may be regarded as using different implementation classes in different implementations for the same component type.

For RIA component type 5, implementation class 374 is used in RIA form 320 and implementation class 382 is used in RIA form 330. In this case, the RIA form 320 and the RIA form 330 may be regarded as using different implementation classes in different implementations for the same component type.

4 is a flowchart illustrating an RIA application execution method according to an embodiment of the present invention.

Referring to FIG. 4, the RIA application execution method acquires a component repository designated by any one of an RIA application and an RIA form (S410).

In this case, the component store may store a RIA component type and a component implementation class that implements the RIA component type.

In this case, the component store may include an address of a component implementation to be used for each RIA component type and a name of the component implementation class included in the component implementation.

In this case, step S410 may include downloading the RIA application to obtain an address of the component store and downloading the component store from the address of the component store.

In addition, the RIA application execution method selects the component implementation class corresponding to the RIA component defined as the RIA component type for each RIA application or the RIA form using the acquired component store (S420).

In this case, the selected component implementation class may be applied to the corresponding RIA component within the scope of the RIA application or RIA form that specifies the component repository including the selected component implementation class.

In this case, when the RIA form does not designate the component store, a RIA application including the RIA form or a component store corresponding to a higher RIA form may be used for the RIA component used in the RIA form.

In addition, the RIA application execution method executes the RIA application using the selected component implementation class (S430).

In this case, step S430 may include loading the selected component implementation class into a memory, binding the RIA component type, and generating and returning an instance of the component implementation by the RIA runtime.

The performing agent of each of the steps shown in FIG. 4 may be an RIA runtime in the client computer.

5 is a flowchart illustrating a method of supporting multiple versions of an RIA component according to an embodiment of the present invention.

Referring to FIG. 5, in the method for supporting multiple versions of an RIA component, the RIA component type and a component implementation class implementing the RIA component type are mapped and stored in the component repository (S510).

In this case, the component store may include an address of a component implementation to be used for each RIA component type and a name of the component implementation class included in the component implementation.

In addition, the method for supporting multiple versions of an RIA component provides the component repository designated by one of an RIA application and an RIA form to a RIA runtime of the client computer at the request of a client computer (S520). .

In this case, the component repository may be used to create an instance of the corresponding RIA component within the scope of the RIA application or RIA form that designates the component repository.

In this case, when the RIA form does not designate the component store, a RIA application including the RIA form or a component store corresponding to a higher RIA form may be used for the RIA component used in the RIA form.

The subject of each step shown in FIG. 5 may be a software module installed in the server computer.

The RIA application execution method and the multi-version support method of the RIA component according to the present invention may be implemented in the form of program instructions that can be executed by various computer means and recorded in a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. Program instructions recorded on the media may be those specially designed and constructed for the purposes of the present invention, or they may be of the kind well-known and available to those having skill in the computer software arts. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks, and magnetic tape, optical media such as CD-ROMs, DVDs, and magnetic disks, such as floppy disks. Magneto-optical media, and hardware devices specifically configured to store and execute program instructions, such as ROM, RAM, flash memory, and the like. Examples of program instructions include not only machine code generated by a compiler, but also high-level language code that can be executed by a computer using an interpreter or the like.

As described above, the RIA application execution method and the multi-version support method of the RIA component according to the present invention are not limited to the configuration and method of the embodiments described as described above, and the above embodiments may be modified in various ways. All or part of each of the embodiments may be configured to be selectively combined to make it possible.

1 is a diagram illustrating a relationship between a RIA component and a component implementation according to the prior art.

2 is a diagram illustrating a relationship between an RIA runtime, an RIA application, and an RIA form and a component repository according to an exemplary embodiment of the present invention.

3 is a diagram illustrating a case of designating a component store for each RIA form using the component store.

4 is a flowchart illustrating an RIA application execution method according to an embodiment of the present invention.

5 is a flowchart illustrating a method of supporting multiple versions of an RIA component according to an embodiment of the present invention.

Claims (11)

Obtaining a component store designated by one of an RIA application and an RIA form and mapping and storing a RIA component type and a component implementation class implementing the RIA component type; Selecting the component implementation class corresponding to the RIA component defined as the RIA component type for each RIA application or the RIA form using the component repository; And Executing the RIA application using the selected component implementation class RIA application execution method comprising the. The method according to claim 1, The selected component implementation class is RIA application execution method, characterized in that applied to the corresponding RIA component in the scope of the RIA application or RIA form that specifies the component repository including the selected component implementation class. The method according to claim 2, If the RIA form does not specify the component store, the RIA application including the RIA form or a component store corresponding to a higher RIA form is used for the RIA component used in the RIA form. How to run. The method according to claim 1, The component repository is For each of the RIA component types, an address of a component implementation to be used and a name of the component implementation class included in the component implementation. The method according to claim 1, Acquiring the component store Downloading the RIA application to obtain an address of the component repository; And Downloading the component repository from the address of the component repository RIA application execution method comprising the. The method according to claim 1, Running the RIA application is Loading the selected component implementation class into memory and binding to the RIA component type; And RIA runtime creates and returns an instance of the component implementation RIA application execution method comprising the. Mapping a RIA component type and a component implementation class implementing the RIA component type to a component repository; And Providing, at the request of the client computer, the component repository specified by one of an RIA application and an RIA form to the RIA runtime of the client computer. Method for supporting multiple versions of the RIA component comprising a. The method of claim 7, The component repository is A method for supporting multiple versions of an RIA component, wherein the component repository is used to create an instance of a corresponding RIA component within a scope of an RIA application or an RIA form. The method according to claim 8, When the RIA form does not specify the component store, the RIA component used for the RIA form or a component store corresponding to the RIA application including the RIA form or a higher RIA form is used. How to support multiple versions. The method of claim 7, The component repository is For each RIA component type, the address of the component implementation to be used and the name of the component implementation class included in the component implementation. A computer-readable recording medium in which a program for executing the method of any one of claims 1 to 10 is recorded.

Images