JP5539170B2 - RIA application execution method and RIA component multiple version support method - Google Patents

Description

  The present invention relates to RIA (Rich Internet Application), and more specifically, RIA component multiple versions that can prevent unnecessary system migration by enabling different business systems operating on a single client computer to use different components and versions. It is about support technology.

  In HTML, an object tag is provided in order to use an externally defined component in a web page. In order to use an object tag, it is necessary to repeatedly describe information on an execution code, a version, and the like for a component to be used. In addition, components defined in this way are always created by loading instances in independent modules, so that they have a structure that is difficult to integrate in an organic unit within an application.

  RIA (Rich Internet Application) is a web application that embodies the functions and features of a traditional desktop application, and is used as a solution to replace a web browser-based application that could not be operated in a complicated manner. In particular, RIA is also called the X Internet, and if RIA is used, it is possible to provide a customer-centric web page that is dynamic and highly convenient that has not been seen on an existing web through a single interface.

  The RIA application provides a component-based programming model. In particular, components that implement business logic with a focus on the user interface are commonly required UIControls such as Buttons, Edits, Combo Boxes, etc. It is a general characteristic of enterprise RIA (Enterprise RIA) that components of different versions exist, and one component shows a very high reuse rate in one form or business domain. .

  Generally, a fixed name is assigned to the RIA component, and an implementation is generated with the same name as the assigned name.

  That is, a component that performs a specific function receives a unique name because it is distinguished from other components, and the RIA runtime is already known for all types of components that it needs, Each component already has a specific implementation. If the names of components and implementations are the same, confusion is minimized during development, maintenance, and repair, and thus there is an advantage that implementation and management are easy.

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

  Referring to FIG. 1, it can be seen that the RIA runtime 110 allows only one implementation 130 for each 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 provides a user interface to support user interaction while running in the RIA runtime 110, or to perform certain business logic that is invisible to the user, This software was developed so that it can be distributed and executed independently so as to be highly reusable.

  The implementation 130 is a set of executable programs implemented using a computer language so that it can be executed on a computer for a target that provides a specific function specified in the RIA component.

  When the component and the implementation correspond to each other at 1: 1, there is no problem when the client computer is connected only to a single business system (implemented as an RIA application). However, if it is necessary to connect to two or more business systems implemented by RIA applications on a single client computer, if the component version used in the business system does not match the component version installed on the client computer, the RIA The business system embodied by the application cannot operate normally. Therefore, in order to match the component versions installed in all connectable client computers with each business system, the versions of components used in the business system must always match. This means that a business system that has been developed and used without any problems must change part or all of the business system by other business systems that are developed later. Will immediately increase the cost of additional development and pose a threat to system security.

  In the enterprise, problems caused by the restriction that the version of the RIA component incorporated in the client computer of the user who must use two or more server systems at the same time must be a single version are as follows.

  i) The application of the existing server system must be modified by developing a new server system.

  ii) To avoid changes to the existing server system, the new system must be developed with the previous version of the RIA component, even though there is a new version of the RIA component with better functionality.

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

  Accordingly, a business system operated by a single client computer can use two or more different versions of component implementations for one component type according to a business domain or form. The need for a new RIA component multi-version support technology that allows different components and versions to be used and prevents unnecessary migration operations is steadily emerging.

  An object of the present invention to solve the above-described problems is to enable multiple component implementations having different versions for each RIA application or RIA form for an RIA component referenced by a name specified in the RIA platform. is there.

  In addition, when the user uses two or more RIA applications, the present invention matches RIA component versions between business systems that are not correlated with each other in order to avoid version conflicts of RIA components incorporated in a client computer. Another purpose is to prevent unnecessary efforts to make it happen.

  The RIA application execution method according to the present invention for achieving the above object is specified by any one of an RIA application and an RIA form, and maps and stores an RIA component type and a component implementation class that implements the RIA component type. Obtaining a component repository to select; for each RIA application or RIA form using the component repository, selecting the component implementation class corresponding to the RIA component defined in the RIA component type; and And executing the RIA application using the selected component implementation class.

  At this time, the selected component implementation class can be applied to the corresponding RIA component within the scope of the RIA application or RIA form that specifies the component storage location including the selected component implementation class.

  At this time, if the RIA form does not designate the component repository, an RIA application including the RIA form or a component repository corresponding to the upper RIA form can be used for the RIA component used for the RIA form.

  At this time, the component storage may include an address of a component implementation used for each RIA component type and a name of the component implementation class included in the component implementation.

  In this case, obtaining the component repository includes downloading the RIA application to obtain the address of the component repository, and downloading the component repository from the address of the component repository. There is.

  In this case, the RIA application is executed by loading the selected component implementation class into a memory and binding the RIA component type to the RIA component type, and an RIA runtime generates an instance of the component implementation. May include a return stage.

  According to another aspect of the present invention, there is provided a method of supporting multiple versions of an RIA component by mapping an RIA component type and a component implementation class that implements the RIA component type and storing them in a component repository; Providing the component repository specified by any one of the RIA forms at the RIA runtime of the client computer.

  At this time, the component storage can be used to generate an instance of the corresponding RIA component within the scope of the RIA application or RIA form designating the component storage.

  According to the present invention, two or more different versions of component implementations (implementation classes) can be used for one component type for each business domain or form, and a single client can be used. It is possible for business systems operated by computers to use different components and versions.

  In addition, the present invention can use component implementations of two or more different versions of RIA components, and can prevent unnecessary system migration work.

  In addition, the present invention can use multiple component implementations having different versions for each RIA application for the RIA component referenced by the name specified in the RIA platform, and is different for each form within one business domain. Since component implementations can be used with the same component name, version conflicts of RIA components incorporated in the client computer can be prevented.

It is a figure which shows the relationship between the RIA component by a prior art, and a component implementation body. FIG. 6 is a diagram illustrating a relationship between an RIA runtime, an RIA application, an RIA form, and a component repository according to an exemplary embodiment of the present invention. It is a figure which shows the case where a component storage place is designated according to RIA form using a component storage place. 5 is an operational flowchart illustrating an RIA application execution method according to an embodiment of the present invention. 3 is an operational flowchart illustrating a method for supporting multiple versions of an RIA component according to an exemplary embodiment of the present invention.

  The present invention will be described in detail with reference to the accompanying drawings. Here, repeated descriptions and detailed descriptions of known functions and configurations that unnecessarily obscure the subject matter of the present invention are omitted. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the concept of the invention to those skilled in the art. Accordingly, the shape and size of elements in the drawings may be exaggerated for a clearer description.

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

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

  Referring to FIG. 2, the RIA runtime 210 may include multiple RIA applications 220.

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

  The RIA application 220 can include zero or more RIA forms 230.

  The present invention provides a mechanism that allows a plurality of implementations (implementation classes) to be specified for one RIA component name, so that a plurality of implementations with one RIA component name can be used in the RIA runtime 210. (Implementation class) can be used at the same time. At this time, the RIA component name is defined by the type, and has a structure in which the component name and the implementation are linked by the type.

  Eventually, the component type can uniquely identify the RIA component, and can be regarded as a reference name of the RIA component that is data typed so as to generate a plurality of instances from one binary code.

  In this case, the RIA component provides a user interface to support user interaction while executing in the RIA runtime 210, or to perform specific business logic that is not visible to the user. This software was developed so that it can be distributed and executed independently so as to be highly reusable.

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

  The RIA application 220 indicates an independent unit capable of operating a business system for each business domain such as a personnel system and an accounting system, and the RIA form 230 is a distribution unit for processing business transactions in the business domain. Can do. For example, the present invention can be implemented by the TypeDef tag technology in XPLATFORM, one of the applicant's products.

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

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

  The RIA form 230 also designates one component storage location 250. That is, in the present invention, each RIA form can designate one component storage. However, each RIA form can also specify no component storage location. In this case, the RIA form in which the component storage location is not specified can use the higher-order RIA form or the component storage location specified by the RIA application.

  That is, the RIA application can be regarded as defining a component type that applies to the entire business domain, and the RIA form can be defined as a component type that is applied to the corresponding form and the lower-level form.

  As a result, the RIA runtime 210 manages a plurality of component repositories 240 and 250 so that a plurality of component implementations can be used with one component type even in the same business domain.

  The component implementation is a set of executable programs implemented using a computer language so that a specific function specified by the component type can be executed on a computer. In particular, the component implementation can be regarded as a set corresponding to the distribution unit of the component implementation class, and can be provided in a form such as DLL (Dynamic Link Library).

  The component storage can store the relationship between the component type and the component implementation and information on the distribution server that can download the component implementation so that the component implementation can be referred to by the component type.

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

  Each component implementation includes one or more class implementations.

  That is, the component storage location may specify the URL of the component implementation to be used and the class name to be mapped to the component type among a plurality of classes existing in the implementation for each component type.

  As can be seen by comparing FIG. 2 and FIG. 1, the present invention uses the RIA component name as a type, manages the connection information between the type and the implementation, and uses the component type in the application. Have a loose connection between them.

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

  1) Packaging implementation classes implemented by RIA component name in units of implementations and registering them in the distribution server.

  2) Map the component name with the implementation class given in 1) and register it in the component repository.

  3) Specify the component storage location to be used in the RIA application and RIA form.

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

  5) The RIA runtime reads the component storage location from the URL of 4).

  6) After confirming and downloading the URL of the component implementation designated in the component storage, it is installed in the client.

  7) After loading the component implementation into memory, bind to the type specified in the component repository.

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

  The processes 4) to 7) are regarded as RIA component loading processes performed by the RIA runtime when the RIA application is executed.

  In the end, according to the present invention, in the RIA application, the type is used without considering the realization during development, and the component dynamically bound using the component realization provided by the RIA runtime is used during execution. It will be.

  FIG. 3 is a diagram showing a case where a component storage location is designated for each RIA form using the component storage location.

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

  The RIA form 320 designates the component repository 340, and the RIA form 330 designates the component repository 350. As described above, according to the present invention, RIA component multiple version support is possible by designating a component storage location for each RIA application or RIA form.

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

  Each RIA form 320, 330 specifies controls using component types to compose a presentation.

  All the controls used in the RIA form 320 and the RIA form 330 correspond to one of five component types of the first type to the fifth type, respectively.

  Each of the component storages 340 and 350 designates the component implementation URL to be used and the class to be mapped to the component type among the classes existing in the implementation for each of the five types of the first type to the fifth type. .

  After loading the RIA forms 320 and 330, the RIA runtime 310 grasps the component type specified by the control, searches for the component implementation from the component storage specified by the RIA form, creates an instance, and returns it to the control. .

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

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

  The component repository 340 maps the implementation class 361 of the implementation 360 to the first type 341. The component repository 340 maps the implementation class 363 of the implementation 360 to the second type 342. The component storage 340 maps the implementation class 371 of the implementation 370 to the third type 343. The component repository 340 maps the implementation class 373 of the implementation 370 to the fourth type 344. The component repository 340 maps the implementation class 374 of the implementation 370 to the fifth type 342.

  The component repository 350 maps the implementation class 361 of the implementation 360 to the first type 351. The component repository 350 maps the implementation class 363 of the implementation 360 to the second type 352. The component repository 350 maps the implementation class 372 of the implementation 370 to the third type 353. The component repository 350 maps the implementation class 381 of the implementation 380 to the fourth type 354. The component repository 350 maps the implementation class 382 of the implementation 380 to the fifth type 352.

  After all, for the first RIA component type, both the RIA form 320 and the RIA form 330 use the implementation class 361, and for the RIA component second type, both the RIA form 320 and the RIA form 330 are implemented. Body class 363 is used.

  However, for the third RIA component type, the RIA form 320 uses the implementation class 371 and the RIA form 330 uses the implementation class 372. In this case, the RIA form 320 and the RIA form 330 are regarded as using different implementation classes in the same implementation for the same component type.

  For the fourth RIA component type, the RIA form 320 uses the implementation class 373 and the RIA form 330 uses the implementation class 381. In this case, the RIA form 320 and the RIA form 330 are considered to use different implementation classes in different implementations for the same component type.

  For the fifth RIA component type, the RIA form 320 uses the implementation class 374 and the RIA form 330 uses the implementation class 382. In this case, the RIA form 320 and the RIA form 330 are regarded as using different implementation classes in different implementations for the same component type.

  FIG. 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 obtains a component repository designated by either one of the RIA application and the RIA form (S410).

  At this time, the component storage can store the RIA component type and the component implementation class that implements the RIA component type in a mapped manner.

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

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

  The RIA application execution method selects the component implementation class corresponding to the RIA component defined in the RIA component type for each RIA application or RIA form using the acquired component repository (S420). .

  At this time, the selected component implementation class can be applied to the corresponding RIA component within the scope of the RIA application or RIA form designating the component storage location including the selected component implementation class.

  At this time, if the RIA form does not specify the component repository, a RIA application including the RIA form or a component repository corresponding to the upper RIA form can be used for the RIA component used for the RIA form.

  The RIA application execution method executes the RIA application using the selected component implementation class (S430).

  In this case, the step (S430) includes loading the selected component implementation class into the memory, binding to the RIA component type, and generating and returning an instance of the component implementation by the RIA runtime. Can be included.

  The execution body of each stage shown in FIG. 4 can be the RIA runtime in the client computer.

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

  Referring to FIG. 5, the RIA component multi-version support method maps an RIA component type and a component implementation class that implements the RIA component type and stores them in a component storage (S510).

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

  Also, the multi-version support method of the RIA component provides the RIA runtime of the client computer with the component storage designated by one of the RIA application and the RIA form according to the request of the client computer (S520).

  At this time, it can be used to generate an instance of the corresponding RIA component within the scope of the RIA application or RIA form designating the component storage location.

  At this time, if the RIA form does not designate the component repository, an RIA application including the RIA form or a component repository corresponding to the upper RIA form can be used for the RIA component used for the RIA form.

  The subject of each stage shown in FIG. 5 may be a software module built into the server computer.

  The RIA application execution method and the RIA component multiple version support method according to the present invention can be recorded in a computer readable medium by being embodied in a form of program instructions executable by various computer means. The computer readable medium may include program instructions, data files, data structures, etc., alone or in combination. The program instructions recorded on the medium may be specially designed and constructed for the present invention, or may be announced and used by employees of the computer software field. Examples of computer-readable recording media include magnetic media such as hard disks, flexible disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, and floppy disks. Hardware specially configured to store and execute program instructions, such as magneto-optical media, ROM (Read Only Memory), RAM (Random Access Memory), flash memory, etc. Hardware device. Examples of the program instructions include not only machine language codes such as those generated by a compiler but also high-level language codes that can be executed by a computer using an interpreter or the like.

  As described above, the RIA application execution method and RIA component multiple version support method according to the present invention are not limited to the configuration and method of the above-described embodiment, and the embodiment can be modified in various ways. In addition, all or some of the embodiments may be selectively combined.

  The present invention is applicable to RIA component multi-version support technology that prevents unnecessary system migration by allowing business systems operated by a single client computer to use different components and versions.

210 RIA runtime 220 RIA application 230 RIA form 240, 250 Component repository 241, 242 Component type 243, 244 Component implementation 245, 246 Implementation class 310 Runtime 320, 330 RIA form 340, 350 Component repository 321, 322, 323 324, 325, 326, 327, 331, 332, 334, 335, 336, 337 Control 360, 370, 380 Implementation 361, 362, 363, 371, 373, 374 Implementation class

Claims (11)

Obtaining a plurality of component storage locations that are specified by any one of the RIA application and the RIA form and map and store the RIA component type and the component implementation class that implements the RIA component type;
Selecting a plurality of component implementation classes corresponding to one RIA component defined in the RIA component type for each RIA application or RIA form using the plurality of component repositories; and the selected Running the RIA application using a component implementation class;
A method for executing an RIA application, comprising:   The selected component implementation class is applied to a corresponding RIA component within an RIA application or an RIA form that specifies the component repository including the selected component implementation class. Item 2. The RIA application execution method according to Item 1.   If the RIA form does not specify the component repository, for the RIA component used for the RIA form, the RIA application including the RIA form or the component repository corresponding to the upper RIA form is used. The RIA application execution method according to claim 2, wherein the RIA application execution method is characterized by the following.   The component storage according to claim 1, wherein the component repository includes an address of a component implementation used for each RIA component type and a name of the component implementation class included in the component implementation. RIA application execution method. Acquiring the component repository is:
Downloading the RIA application to obtain the address of the component repository; and downloading the component repository from the address of the component repository;
The RIA application execution method according to claim 1, further comprising: The step of executing the RIA application includes:
After loading the selected component implementation class into memory and binding to the RIA component type; and an RIA runtime creating and returning an instance of the component implementation;
The RIA application execution method according to claim 1, further comprising: Mapping the component embodied body class that embodies the RIA component type and RIA component type step stores a plurality of components stored plant; RIA runtime to execute RIA applications and client computer corresponds to one of the RIA components Providing the RIA runtime with the plurality of component repositories specified by any one of an RIA application and an RIA form at the request of the client computer so that a plurality of the component implementation classes can be used;
A method for supporting multiple versions of an RIA component, comprising:   The multi-version support of the RIA component according to claim 7, wherein the component repository is used for instantiating the corresponding RIA component within the scope of the RIA application or RIA form designating the component repository. Method.   If the RIA form does not specify the component repository, an RIA application including the RIA form or a component repository corresponding to the upper RIA form is used for the RIA component used for the RIA form. The method for supporting multiple versions of an RIA component according to claim 8.   8. The RIA according to claim 7, wherein the component repository includes 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. How to support multiple versions of components.   A computer-readable recording medium in which a program for performing the method according to any one of claims 1 to 10 is recorded.

Images