JP2002202886A - Application development system and its method and application development program and application generation method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide an application development system capable of easily developing an application whose maintainability is excellent capable of flexibly facilitating countermeasures to the change of the system environment of a platform or the like. SOLUTION: A designing tool 1 supports the design of an application based on the combination of a plurality of logical components based on logical component information 4, and outputs logical design information 5 acquired from the design. A source generation processing part 2 and a compiler 3 generates an application (performable file 9) performable on a specific platform based on the logical design information 5 outputted by the designing tool 1 and the physical mounting information (physical component information 6 and component library 8) of the software components.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to an application development method for developing an application by combining a plurality of software components.

[0002]

2. Description of the Related Art Conventionally, there has been known an application development method for developing an application by combining a plurality of software components. In such a conventional application development method, as shown in FIG.
By combining physical components 42 which are software components mounted for a specific platform 41 at a physical level (see reference numeral 43), the application 4
0 development.

[0003]

However, in the above-described conventional application development method, a combination of software components is described at a physical level, and therefore a platform (OS, middleware, language, etc.) on which the software components are mounted is used. , A communication environment, etc.), and there is a problem that it is difficult to transfer the developed application 40 to another platform.

Further, in the above-described conventional application development method, a description of a process inherent to the application (for example, a business process) and a description of a platform-specific process are mixed in the application 40 to be developed. There is a problem of poor maintainability.

[0005] The present invention has been made in view of the above points, and is an application development method capable of easily developing an application with excellent maintainability that can flexibly cope with changes in the system environment such as a platform. It is an object to provide a system, a method thereof, an application development program and an application generation method.

[0006]

FIG. 20 is a diagram for schematically explaining an application development method according to the present invention. As shown in FIG. 20, according to the present invention, the platform 4 corresponds to each of a plurality of software components.
A logical component 52 is provided by extracting a part that does not depend on 1 and a combination of these logical components 52 (see reference numeral 53) designs an application. Then, the logical design information obtained by such a design and the physical mounting information of the software component (the physical component information including the correspondence between the physical component 42 and the logical component 52, and the mounting information of the physical component 42 are An application 40 that can be executed on a specific platform 41 is generated based on the stored component library).

Under such a basic principle, the present invention provides a first solution to an application development system for developing an application by combining a plurality of software components, each of which corresponds to a plurality of software components. Based on logical component information including logical component definition information that is a logical component provided and extracted from the software component and does not depend on the system environment, it is possible to design an application by combining a plurality of logical components. A logic design unit that supports and outputs logical design information obtained by the design; and executes on a system environment based on the logical design information output by the logical design unit and the physical mounting information of the software component. A physical implementation unit for generating a possible application. To provide application development system.

[0008] In the first solution, it is preferable that the logical design information is described in an XML language.

In the above-mentioned first solution, the logical design unit and the physical mounting unit are provided on a client computer and a server computer connected to each other via a network, respectively. It is preferable that the logical design information is transferred to and from a server computer.

According to a second aspect of the present invention, there is provided an application development method for developing an application by combining a plurality of software components with a logic component provided corresponding to each of the plurality of software components. Supporting the design of an application by combining a plurality of logical components based on logical component information including logical component definition information obtained by extracting a portion of the software component that does not depend on the system environment; And generating an application executable on a system environment based on the logical design information and the physical mounting information of the software component obtained by the method.

Further, the present invention provides, as a third solution, an application development program for developing an application by combining a plurality of software components, using a logic component provided corresponding to each of the plurality of software components. A procedure for supporting the design of an application by combining a plurality of logical components based on logical component information including logical component definition information obtained by extracting a part independent of the system environment from the software components; And causing the computer to execute a procedure for outputting the logical design information obtained by the application development program.

According to a fourth aspect of the present invention, there is provided an application development program for developing an application by combining a plurality of software components, wherein a logic component provided for each of the plurality of software components is provided. A procedure for reading logical design information obtained by a combination of logical components obtained by extracting a part that does not depend on the system environment from the software components, and reading the logical design information and the physical And a program for causing a computer to execute a procedure for generating an application executable on a system environment on the basis of statistical implementation information.

According to a fifth aspect of the present invention, there is provided an application generation method for generating an application by combining a plurality of software components.
Displaying logical component specific information provided for each of the plurality of software components, prompting the user to select a logical component, and including definition information on the logical component selected by the user; Generating logical design information based on logical component information; and generating an application based on the logical design information and physical mounting information of the software component. provide.

According to the present invention, the development of an application performed by a combination of software components is described in (1)
A process (logical layer) of designing an application by combining logical components that are extracted from software components that do not depend on the system environment such as a platform,
(2) Based on the logical design information obtained by this design, it is divided into a process (physical layer) for generating an application by combining physical components that are software components depending on the system environment. Can be used in common regardless of the final system environment, and by preparing each part of the physical layer individually according to the final system environment, development of applications corresponding to the system environment It can be performed. For this reason, it is possible to easily develop an application with excellent maintainability that can flexibly respond to changes in the system environment.

Further, according to the present invention, the logical design information for linking the processing of the logical layer and the processing of the physical layer is described in a highly versatile language called XML language, so that both the physical layer and the logical layer can be described. The degree of freedom can be given. This makes it easy to replace each layer, and
The life of the logical expression of the business process of the application can be extended.

Further, according to the present invention, a logical layer (logical design unit) and a physical layer (physical mounting unit) are provided on a client computer and a server computer, respectively, and a logical design is performed between the client computer and the server computer. By transferring the information, the amount of communication between the client computer and the server computer can be suppressed. Therefore, even in the Internet environment, it is possible to develop an application on the server computer side from the client computer side, and the application can be applied to a service that provides an open application development environment in the Internet environment.

[0017]

Embodiments of the present invention will be described below with reference to the drawings. 1 to 11 are views for explaining an embodiment of an application development system according to the present invention. In this embodiment, a case where the application development system is realized on a single computer will be described as an example.

As shown in FIG. 1, the application development system according to the present embodiment develops an application by combining a plurality of software components, and includes a design tool (logical design unit) 1 and a source generation process. And a compiler (executable file generation unit) 3. Note that a physical mounting unit is configured by the source generation processing unit 2 and the compiler 3.

The design tool 1 supports design of an application based on a combination of a plurality of logical components based on the logical component information 4 and outputs logical design information 5 obtained by the design. Here, the logical component information 4 input to the design tool 1 includes definition information of the logical component, and is described as character string data in, for example, XML language (see FIGS. 7A and 7B). . The logical component is a component used for designing an application. The logical component is provided corresponding to each of a plurality of software components, and is a component extracted from a software component that does not depend on a platform (system environment). is there. The logical design information 5 output by the design tool 1 includes attribute information of each logical component and connection information between the logical components, and is described as character string data in the XML language, for example ( See FIG. 8).

On the other hand, the source generation processing unit 2 and the compiler 3 specify based on the logical design information 5 output by the design tool 1 and the physical mounting information of the software components (the physical component information 6 and the component library 8). To generate an application (executable file 9) that can be executed on the platform of the third embodiment.

Specifically, the source generation processing unit 2 generates a source code 7 based on the logical design information 5 and the physical component information 6 output by the design tool 1. The physical component information 6 input to the source generation processing unit 2 includes a correspondence between a physical component and a logical component mounted for a specific platform, for example, as character string data in XML language. (See FIGS. 9 and 10 (a) (b) (c)). The correspondence between logical components and physical components is not limited to one-to-one, but may be one-to-many. For example, the logical component “A” may be a physical component “a”, the logical component “A” may be a physical component “a + b”, and the logical component “A” may be a physical component “a + b”. Can also define multiple physical components. More specifically, the physical component may be “UpdateWithCheck” for the logical component “update with check”, or the physical component may be “Check” + “Update” for the logical component “update with check”. ", And a plurality of physical components can be defined for the same logical component" update with check ". The source code 7 output by the source generation processing unit 2 is described as character string data in a programming language such as Java (registered trademark), for example (see FIG. 11).

Further, the compiler 3 is provided on a specific platform based on the source code 7 generated by the source generation processing unit 2 and the component library 8 storing mounting information (interface, type definition, etc.) of each physical component. To generate an executable file 9 which can be executed by. The physical components stored in the component library 8 include:
EJB, JavaBeans, and Java classes are used.

In the above, a logical layer is constituted by the design tool 1, the logical component information 2 and the logical design information 5,
Source generation processing unit 2, compiler 3, physical component information 6,
The source code 7, the component library 8, and the executable file 9 constitute a physical layer.

FIG. 2 is a diagram showing details of the design tool 1 shown in FIG.

As shown in FIG. 2, the design tool 1 has a logical component tool information setting unit (specification information generating unit) 11 for generating logical component tool information 12 based on the logical component information 4.
And a design tool body (design part body) 13 that supports the design of an application based on a combination of the logic components based on the logic component tool information 12 generated by the logic component tool information setting unit 11. The logical component information 4 includes logical component basic information 4a (ID and attribute information of each logical component, input / output information, etc.) and logical component related information 4b (inter-component information) as logical component definition information. Connection information). The logical component tool information 12 represents specification information of each logical component, and includes input / output specifications (logical component input / output specifications 12a) of each logical component.
Connection specifications between logical components (logical component connection specifications 12b)
And attribute specification of each logical component (logical component attribute specification 12c)
And The logical design information 5 output from the design tool body 13 includes attribute information of each logical component (component attribute information 5a) and connection information between the logical components (component connection information 5b).

The design tool 1 is a design tool body 1
3 has a screen input / output interface unit 14 connected thereto. Here, the screen input / output interface unit 14
Provides a graphical user interface (GUI) that represents a plurality of logical components that are the basis of design as icons on a tool screen. The application to be developed is composed of a graph structure that connects icons with relational lines. It is possible to express combinations of software components to be used. The screen input / output interface unit 14 can be realized as an interface program that operates on an application such as a Web browser.

FIG. 3 is a view showing an example of the tool screen.
As shown in FIG. 3, the tool screen 20 displays the palette area 2
1 and a work area 22. In the pallet area 21, a plurality of icons 23 corresponding to the logical components serving as the basis of the design are displayed in a list based on the logical component information 4. In the work area 22, a plurality of icons 24 pasted based on the icons 23 arranged in the pallet area 21 are displayed. The icons 24 arranged in the work area 22 correspond to individual software components constituting an application to be developed.

In such a tool screen 20, the user can perform various operations (pasting, moving, relating, etc. of icons) on the icons using an input device such as a mouse.
Can be performed, and an application can be designed by combining logical components in conjunction with an operation on these icons.

Specifically, for example, after clicking a left mouse button on an arbitrary icon (icon A, B, C) among a plurality of icons 23 arranged in the pallet area 21, By clicking the left mouse button again at an arbitrary position, the icon 24 (icon A, B, C) can be pasted on the work area 22 (see reference numeral 26). After the icon 24 is pasted on the work area 22 in this manner, the icon 2
4, a menu (not shown) is popped up by clicking the right button of the mouse, and by appropriately selecting an item in this menu, the attribute of the logical component and the like (the name of the logical component (“parent”, “parent child1 "etc.) can be set.

Further, the user presses the left button of the mouse on the output terminal of the icon (icon A in FIG. 3) corresponding to the original component for setting the relationship among the icons arranged in the work area 22. By pressing (dragging) the mouse to the icon (icons B and C in FIG. 3) corresponding to the component for which the relationship is to be set, the relationship line 25 between the icons can be defined. (See reference numeral 27).

Operation for icons on the tool screen 20 (placement, movement, association of icons, etc.)
Is realized by a basic operation of a mouse or the like. The basic operations of the mouse and the like are unified between the logical components.

Next, the operation of the present embodiment having the above configuration will be described.

First, the processing of the logical layer (design tool 1) of the application development system shown in FIGS. 1 and 2 will be described with reference to FIGS.

FIG. 4 shows the design tool 1 shown in FIG. 1 and FIG.
6 is a flowchart for explaining the operation of the logical component tool information setting unit 11 of FIG.

As shown in FIG. 4, the logical component tool information setting section 11 of the design tool 1 first reads the basic logical component information 4a of the logical component information 4 (step 10).
1) Based on the basic logical component information 4a, a logical component input / output specification 12a and a logical component attribute specification 12c are generated for each logical component (steps 102 and 103).
Next, the logical component information 4b is read from the logical component information 4 (step 104), and the logical component information 4b is read.
, A logical component connection specification 12b is generated for each combination of logical components (step 105).

FIGS. 7A and 7B are views showing an example of the logical component information 4. FIG. FIG. 7A shows the logical component basic information 4.
It shows the entire information including a part (a of each logical component) and logical component related information 4b (connection information between individual logical components). FIG. 7B shows logical component basic information 4.
2 shows individual information including a part (attribute information and input / output information of each logical component).

Here, the ID of each logical component is described in the part (A) of FIG. 7A (<compone
nt type = "A"/>). Further, in the part of the symbol (B), connection information between the individual logical components that is the basis of the logical component connection specification 12b is described (<connection from = "A" to = "B").
/> Etc.). Note that the part "<connection from =" A "to =" B "/>" indicates that the software component A can be connected to the software component B.

Further, in the part of the symbol (C) in FIG.
Attribute information of each logical component as a source of the logical component attribute specification 12c is described (<property name = "name" type
= "string"/>). Note that "<property name =" name "typ
e = "string"/><property name = "option" type = "string"
"/>" Indicates that there are two character string attributes "name" and "option". Further, in the part of the symbol (D), the input / output information of each logical component that is the basis of the logical component input / output specification 12a is described (<terminalid = "out").
type = "out" min = 1 max = 3> ... </ terminal> etc.) In addition,
"<Terminal id =" out "type =" out "min = 1 max = 3><conn
ectwith type = "B"/><connectwith type = "C"/></ termi
The “nal>” portion has an output terminal “out”, and one to three connections can be made, and the connection destination is a software component B or C.

FIG. 5 shows the design tool 1 shown in FIGS.
6 is a flowchart for explaining the operation of the design tool body 13 of FIG.

As shown in FIG. 5, the screen input / output interface unit 14 of the design tool 1 presents a tool screen 20 shown in FIG. Thus, the design of the application by the combination of the logical components is supported (steps 201 and 202).

More specifically, the screen input / output interface unit 14 allows the user to operate the palette area 21 of the tool screen 20.
Clicks the left mouse button on an arbitrary icon (icons A, B, C) among the plurality of icons 23 arranged in the window 23, and then clicks the left mouse button again at an arbitrary position in the work area 22 Thereby, the icon 24 (icon A, B, C) is pasted on the work area 22 (step 201).

Further, among the icons arranged in the work area 22, the left button of the mouse is pressed on the output terminal of the icon (the icon A in FIG. 3) corresponding to the original component for which the relation is to be set. While pressing, the relationship line 25 between the icons is defined by moving (dragging) the mouse to the icon (icons B and C in FIG. 3) corresponding to the component for which the relationship is to be set (step 202). ).

Thereafter, the design tool body 13 checks the validity of the connection point of each logical component based on the logical component input / output specification 12a of the logical component tool information 12 (step 2).
03) If not valid, return to step 202 to continue the process; if valid, proceed to step 205 (step 204).

Further, the design tool main body 13 checks the validity of the connection relationship between the logical components based on the logical component connection specification 12b of the logical component tool information 12 (step 2).
05) If not valid, return to step 202 to continue the process; if valid, proceed to step 207 (step 206).

Thereafter, the user clicks the right button of the mouse on the icon 24 pasted on the work area 22, pops up a menu (not shown), and selects an item in this menu as appropriate to execute a logical operation. When the attribute of the component is set (Step 207), the validity of the attribute of each logical component is checked based on the logical component attribute specification 12c of the logical component tool information 12 (Step 208). To continue the processing, and if appropriate, proceed to step 210 (step 20).
9).

Finally, it is determined whether or not processing of all logical components has been completed (step 210). If the processing has been completed, logical design information 5 is output (step 2).
11).

FIG. 8 is a diagram showing an example of the logical design information 5. The logical design information 5 includes component attribute information 5a (see reference numeral (E)) and component connection information 5b (see reference numeral (F)). Contains. Here, the logical design information 5 shown in FIG.
Is an icon B (named "child1", option "11") and an icon B under a combination of logical parts (icon A (name is "parent", option "1") as shown in FIG. C (namely, “child2” and option “12”) are connected in a tree shape.

Next, the processing of the physical layer (source generation processing unit 2 and compiler 3) of the application development system shown in FIG. 1 will be described with reference to FIG.

FIG. 6 is a flow chart for explaining the operation of the source generation processing section 2 shown in FIG.

As shown in FIG. 6, the source generation processing unit 2
Is the logical design information 5 output by the design tool 1.
The source code 7 is generated based on the (component attribute information 5a and component connection information 5b) and the physical component information 6.

FIGS. 9 and 10 (a), (b) and (c) are views showing an example of the physical component information 6. FIG. 9 shows information related to a code generation method for each software component in the physical component information 6, and shows a correspondence relationship between a physical component and a logical component mounted for a specific platform, The attribute-related information and the connection-related information of each physical component are included. FIGS. 10A, 10B, and 10C show information related to the entire code generation method.

Here, the method of generating the initialization code of each software component is described in the portion of the symbol (G) in FIG. 9 (<new code = "ClassX% name% = ClassX.newinstan").
ce () "/>, etc. The code (H) describes an attribute setting code generation method for each software component (<property name =" option "code ="% name%. addItem
("OPTION", "% value%", "string") "/>, etc. In addition, the part (I) describes a method of generating a component connection setting code of each software component (< code = "% from%.
addItem ("CHILD",% to%); /> etc.). The symbol (G)
The part (H) and the part (I) are the source of the attribute setting code 7b and the component connection setting code 7c of the source code 7, respectively, and the item "% xxx%" is the logical design information 5 Of the source code 7 is generated.

In the part of the code (J) in FIG. 10A, a method of generating an initial setting code which is a source of the initial setting code 7a of the source code 7 is described (<init file = "fw1ini").
t.java "/>), the code (K) is the source code 7
Describes the method of generating the termination processing setting code that is the basis of the termination processing setting code 7d (<term file = "fw1term.ja
va "/>. The"<init file = "fw1init.java"/>"is a template file (fw1ini) shown in FIG.
t.java) to import.
File = "fw1term.java"/>"is a description for importing the template file (fw1term.java) shown in FIG.

Based on such physical component information 6, the source generation processing unit 2 first outputs the initial setting code 7a of the source code 7, as shown in FIG. 6 (step 3).
01).

Next, the component attribute information 5a of the logical design information 5 is read (step 302), and based on the component attribute information 5a and the physical component information 6, the attribute setting code of the source code 7 is set for each software component. 7b is generated (step 303).

Thereafter, it is determined whether or not processing of all software components has been completed (step 304). If the processing has not been completed, the process returns to step 302 to continue the processing, and the processing has been completed. In this case, the process proceeds to step 305.

Next, the component connection information 5b of the logical design information 5 is read (step 305), and the component connection setting of the source code 7 for each software component is performed based on the component attribute information 5a and the physical component information 6. The code 7c is generated (Step 306).

Thereafter, it is determined whether or not processing of all software components has been completed (step 307). If the processing has not been completed, the process returns to step 305 to continue the processing, and the processing has been completed. In this case, the end processing setting code 7d of the source code 7 is output based on the physical component information 6 (step 308), and the entire processing ends. FIG.
1 is a diagram showing an example of the source code 7 generated in this way.

The source generation processing unit 2
After the source code 7 is generated, as shown in FIG. 1, the source code 7 is applied to the compiler 3 and executed on a specific platform based on the mounting information of each physical component stored in the component library 8. Generate a possible executable file 9.

As described above, according to the present embodiment, the development of an application that is performed by combining software components is performed by: (1) A logic component that is obtained by extracting a portion of a software component that does not depend on a system environment such as a platform. The process is divided into a process of designing an application by combining them (logical layer) and a process of creating an application by combining (2) physical components that are software components depending on the system environment (physical layer). Each part can be used in common regardless of the final system environment, and by preparing each part of the physical layer individually according to the final system environment, it is possible to develop applications corresponding to the system environment. It can be carried out. For this reason, it is possible to easily develop an application with excellent maintainability that can flexibly respond to changes in the system environment.

More specifically, (1) based on the logical design information 5 obtained by the processing of the logical layer (design tool 1), the application corresponding to a plurality of system environments is divided into the physical layer components and processing (source). It can be generated by replacing the generation processing unit 2, the physical component information 6, the component library 8, and the compiler 3). Also,
(2) Logical design information 5 obtained by processing of the logical layer
Is less affected by the system environment, so even if the system environment to be executed changes significantly due to technological advances, etc., by preparing the physical layer components and processing for each application in accordance with the new system environment, the new An application executable on the system environment can be easily generated. Further, (3) the processing of the logical layer can be limited to outputting specific logical design information 5 without being bound by the physical layer.
Development tools that operate on multiple system environments can be easily prepared.

According to the present embodiment, the logical design information 5 for linking the processing of the logical layer and the processing of the physical layer is represented by X
Because it is described in a highly versatile language called ML language,
A degree of freedom can be given to both the physical layer and the logical layer, the replacement of each layer can be facilitated, and the life of the logical representation of the business process of the application can be extended.

In the above-described embodiment, the source generation processing unit 2 generates the source code 7 including the attribute setting code and the component connection setting code, and the compiler 3 executes the software based on the source code 7 based on the source code 7. The executable file 9 in which the attribute of the component and the connection relation between the software components are set is generated. However, as in the other embodiments shown in FIGS. The connection relation between them may be set at the time of execution.

Hereinafter, another embodiment of the application development system according to the present invention will be described with reference to FIGS. The embodiments shown in FIGS. 12 to 17 are the same as those shown in FIGS. 1 to 11 except that the attribute of the software component and the connection information between the software components are set when the executable file is executed. Is substantially the same as the embodiment shown in FIG. In the embodiments shown in FIGS. 12 to 17, the same parts as those in the embodiments shown in FIGS. 1 to 11 are denoted by the same reference numerals, and detailed description will be omitted.

As shown in FIG. 12, in another embodiment of the present invention, a source code 7 including an interpreted component object generation code is generated by a source generation processing unit 2 ', and based on this source code 7, When executing the executable file 9 generated by the compiler 3
Execution processing unit 15 and component object generation processing unit 16
With this, the attribute of the software component and the connection information between the software components are set.

FIG. 13 is a flowchart for explaining the operation of the source generation processing section 2 'shown in FIG.

As shown in FIG. 13, the source generation processing unit 2 ′ generates a source code 7 based on the physical component information 6.

FIGS. 15 and 16 (a), (b), (c) and (d) are diagrams showing an example of the physical component information 6. FIG. Among them, FIG.
The information related to the component object generation method for each software component in the physical component information 6 is shown. Also,
FIGS. 16 (a), (b), (c), and (d) show information related to the entire code generation method.

In the part (L) in FIG. 16A, a method for generating an initial setting code which is a source of the initial setting code 7a (see FIG. 13) of the source code 7 is described (<init file = "
fw1init.java "/>) and the code (M) indicates the interpreted component object generation code 1 of the source code 7.
7e (see FIG. 13) is described (<main file = "fw1main.java"/>), and the code (N) indicates the end processing setting code 7d ( The method for generating the termination processing setting code which is the basis of the processing shown in FIG. 13 is described (<term file = "fw1term.java" /
>). Note that “<init file =" fw1init.java "/>” is a template file (fw1init.j) shown in FIG.
ava) is a description for importing, "<main fil
e = "fw1main.java"/>"is a description for importing the template file (fw1main.java) shown in FIG. 16 (c), and"<term file = "fw1term.java"/>" Is a template file (fw1te) shown in FIG.
rm.java).

Based on such physical component information 6, the source generation processing unit 2 'first outputs an initial setting code 7a of the source code 7, as shown in FIG. 13 (step 401).

Next, an interpreter type part object generation code 7e of the source code 7 is output (step 4).
02).

Thereafter, the end processing setting code 7d of the source code 7 is output based on the physical part information 6 (step 403), and the entire processing is ended. FIG. 17 is a diagram showing an example of the source code 7 generated in this way.

After the source code 7 is generated by the source generation processing unit 2 'in this way, the source code 7 is applied to the compiler 3 and stored in the parts library 8 as shown in FIG. An executable file 9 executable on a specific platform is generated based on mounting information of each physical component.

The executable file 9 generated in this way is executed by the execution processing unit 15, which executes the component object generation processing unit 1 in the course of the processing.
6 to generate the component object of the software component, and set the attribute of the software component and the connection information between the software components.

FIG. 14 is a flowchart for explaining the operation of the component object generation processing section 16 shown in FIG.

As shown in FIG. 14, the component object generation processing unit 16 outputs the logical design information 5 (the component attribute information 5a and the component connection information 5) output from the design tool 1.
Based on b) and the physical component information 6, a component object is generated, and attributes and connection information between components are set.

Specifically, first, the component attribute information 5a of the logical design information 5 is read (step 501), and a component object is identified for each software component based on the component attribute information 5a and the physical component information 6. Generate and set attributes (step 502).

Thereafter, it is determined whether or not the processing of all software components has been completed (step 503). If the processing has not been completed, the process returns to step 501 to continue the processing, and the processing has been completed. In this case, the process proceeds to step 504.

Next, the component connection information 5b of the logical design information 5 is read (step 504), and cross-reference information is set for each software component based on the component attribute information 5a and the physical component information 6, The parts are connected (step 505).

Thereafter, it is determined whether or not processing of all software components has been completed (step 506). If the processing has not been completed, the process returns to step 504 to continue the processing, and the processing has been completed. In this case, the entire process is terminated.

In the embodiments shown in FIGS. 1 to 11 and FIGS. 12 to 17, the case where the application development system is realized on a single computer is taken as an example. However, the present invention is not limited to this, and the application development system can be realized in a distributed development environment as shown in FIG. More specifically, as shown in FIG. 18, a plurality of client computers 31 and server computers 33 connected to each other via a network 32 such as the Internet.
, A logical layer (design tool 1 and logical component information 4) is provided on the client computer 31, and a physical layer (source generation processing unit 2, compiler 3, physical component information 6, source code 7, component library 8, executable file) 9) may be provided on the server computer 33. In this case, since the logical design information 5 in the XML language or the like without the physical component mounting information is transferred between the client computer 31 and the server computer 33, the communication amount is reduced. Can be. Therefore, even in the Internet environment,
It becomes possible to develop an application on the server computer 33 side from the client computer 31 side, and it becomes possible to apply to a service which provides an open application development environment in the Internet environment.

In the embodiments shown in FIGS. 1 to 11 and FIGS. 12 to 17 described above, the source code 7 generated by the source generation processing unit 2 by the compiler 3 and the components Although the library 8 is integrated, the present invention is not limited thereto, and the source code 7 and the component library 8 may be integrated by a component selection method, a component plug-in method, or the like.

Further, in the above-described embodiments shown in FIGS. 1 to 11 and FIGS. 12 to 17, the logical component information 4 and the physical
Although described in the L language, the present invention is not limited to this, and can be described in any format such as a table format.

In the embodiments shown in FIGS. 1 to 11 and the embodiments shown in FIGS. 12 to 17, the design tools 1 and
The source generation processing unit 2 and the compiler 3 can be realized as a program. An application development program including such a program is, for example, shown in FIG.
4 can be recorded on a computer-readable recording medium such as a flexible disk 34 or a CD-ROM 35. The procedure shown in FIG.
An application can be developed according to the procedure shown in FIG.

The recording medium of the present invention includes
Not limited to flexible disks and CD-ROMs, but also magnetic disks, internal memories, hard disks, optical disks (CD-R, DVD (Digital Versatile Disk), etc.),
As long as a program can be recorded and a computer can read the recording medium, such as a magneto-optical disk (MO (Magneto Optical), a semiconductor memory, etc.), the recording format may be any format. In addition, as a recording medium, a carrier wave transmitted on a network,
It also includes information transmission media.

Also, an OS (Operating System) running on the computer based on instructions of a program installed in the computer from the recording medium,
MW for database management software, network software, etc.
(Middleware) or the like may execute a part of each process for realizing the present invention.

Further, the recording medium in the present invention is not limited to a medium independent of a computer, but also includes a recording medium in which a program transmitted via a LAN, the Internet, or the like is downloaded and stored or temporarily stored.

Furthermore, the number of recording media is not limited to one, and the case where the processing of the present invention is executed from a plurality of media is also included in the recording medium of the present invention, and any medium configuration may be used.

[0089]

As described above, according to the present invention, it is possible to easily develop an application having excellent maintainability and capable of flexibly responding to changes in the system environment.

[Brief description of the drawings]

FIG. 1 is a system configuration diagram showing an embodiment of an application development system according to the present invention.

FIG. 2 is a block diagram showing details of a design tool (logic design unit) of the application development system shown in FIG. 1;

FIG. 3 is a view showing an example of a tool screen presented to a user in the application development system shown in FIG. 1;

FIG. 4 is a flowchart for explaining the operation of a logical component tool information setting unit (specification information generation unit) of the design tool shown in FIGS. 1 and 2;

FIG. 5 is a flowchart for explaining the operation of a design tool main body (design unit main body) of the design tool shown in FIGS. 1 and 2;

FIG. 6 is a flowchart for explaining the operation of a source generation processing unit shown in FIG. 1;

FIG. 7 is a view showing an example of logical component information used in the application development system shown in FIG. 1;

FIG. 8 is a view showing an example of logical design information output by the application development system shown in FIG. 1;

9 is a diagram showing an example of physical component information (information related to a code generation method for each software component) used in the application development system shown in FIG.

FIG. 10 is a view showing an example of physical component information (information related to an entire code generation method) used in the application development system shown in FIG. 1;

FIG. 11 is a view showing an example of a source code generated by the application development system shown in FIG. 1;

FIG. 12 is a system configuration diagram showing another embodiment of the application development system according to the present invention.

FIG. 13 is a flowchart for explaining the operation of the source generation processing unit shown in FIG. 12;

FIG. 14 is a flowchart for explaining the operation of the part object generation processing unit shown in FIG. 12;

15 is a view showing an example of physical component information (information related to a code generation method for each software component) used in the application development system shown in FIG. 12;

16 is a diagram showing an example of physical component information (information related to the entire code generation method) used in the application development system shown in FIG.

FIG. 17 is a view showing an example of a source code generated by the application development system shown in FIG. 12;

FIG. 18 is a diagram showing an example of a distributed development environment to which an application development system according to the present invention is applied.

FIG. 19 is a diagram for schematically explaining a conventional application development method.

FIG. 20 is a diagram schematically illustrating an application development method according to the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Design tool (logical design part) 2, 2 'Source generation processing part (physical mounting part) 3 Compiler (physical mounting part) 4 Logical part information 4a Logical part basic information 4b Logical part related information 5 Logical design information 5a Part attribute Information 5b Component connection information 6 Physical component information 7 Source code 7a Initial setting code 7b Attribute setting code 7c Component connection setting code 7d End processing setting code 8 Component library 9 Executable file 11 Logical component tool information setting unit (specification information generation unit) 12 Logical component tool information (specification information of each logical component) 12a Logical component input / output specification 12b Logical component connection specification 12c Logical component attribute specification 13 Design tool main body (Design main body) 14 Screen input / output interface section 15 Execution processing section 16 Parts Object generation processing unit 20 Tool screen 21 Palette area 22 Work Area 23, 24 Icon 25 Relationship Line 31 Client Computer 32 Network 33 Server Computer 34 Flexible Disk (Recording Medium) 35 CD-ROM (Recording Medium) 40 Application 41 Platform (System Environment) 42 Physical Parts 43 Physical Combination Information 52 Logic parts 53 Logical combination information

Claims (12)

[Claims] 1. An application development system for developing an application by combining a plurality of software components, wherein the logic components are provided corresponding to each of the plurality of software components and do not depend on the system environment among the software components. A logic design unit that supports design of an application based on a combination of a plurality of logic components based on logic component information including logic component definition information obtained by extracting a part, and outputs logical design information obtained by the design. And a physical mounting unit that generates an application executable on a system environment based on the logical design information output by the logical designing unit and the physical mounting information of the software component. Development system. 2. A specification information generating unit for generating specification information of each of the logical components based on the logical component information, and a specification information of each of the logical components generated by the specification information generating unit. 2. The application development system according to claim 1, further comprising: a design unit main body that supports designing of an application based on a combination of the respective logical components based on the design. 3. The specification information of each logical component includes input / output specifications of each logical component, connection specifications between the logical components, and attribute specifications of each logical component. Application development system described. 4. The physical mounting section according to claim 2, wherein said logical design information is output by said logical designing section and physical component information including a correspondence relationship between physical components and logical components mounted for a system environment. A source code generation unit that generates a source code based on the source code generated by the source generation processing unit and a component library in which mounting information of each of the physical components is stored. The application development system according to claim 1, further comprising an executable file generation unit that generates an executable file. 5. A source generation processing unit for generating a source code based on physical component information including a correspondence between a physical component and a logical component mounted for a system environment; An executable file generation unit that generates an executable file executable on a system environment based on a source code generated by a source generation processing unit and a component library in which mounting information of each of the physical components is stored; At the time of execution of the executable file generated by the file generation unit, a component object is generated based on the logical design information output by the logical design unit and the physical component information, and a component attribute and a component 2. The application development system according to claim 1, further comprising: a component object generation processing unit that sets a connection relationship of the application. 6. The application development system according to claim 1, wherein the logical design information includes attribute information of each of the logical components and connection information between the logical components. 7. The application development system according to claim 1, wherein said logical design information is described in an XML language. 8. The logical design unit and the physical mounting unit are respectively provided on a client computer and a server computer connected to each other via a network, and the logical design unit is provided between the client computer and the server computer. 8. The application development system according to claim 1, wherein information is transferred. 9. An application development method for developing an application by combining a plurality of software components, wherein the logic components are provided corresponding to each of the plurality of software components and do not depend on a system environment among the software components. A step of supporting an application design by combining a plurality of logical components based on the logical component information including the definition information of the logical component obtained by extracting the part; and Generating an application executable on the system environment based on the physical mounting information. 10. An application development program for developing an application by combining a plurality of software components, wherein the logic component is provided corresponding to each of the plurality of software components and does not depend on the system environment among the software components. A procedure for supporting the design of an application based on a combination of a plurality of logical components based on logical component information including logical component definition information obtained by extracting a part, and a procedure for outputting logical design information obtained by the design An application development program for causing a computer to execute the following. 11. An application development program for developing an application by combining a plurality of software components, wherein the logic component is provided corresponding to each of the plurality of software components and does not depend on the system environment among the software components. A procedure for reading the logical design information obtained by combining the logical parts obtained by extracting the parts, and can be executed in the system environment based on the read logical design information and the physical mounting information of the software parts. An application development program for causing a computer to execute a procedure for generating a simple application. 12. An application generation method for generating an application by combining a plurality of software components, wherein specific information of a logic component provided corresponding to each of the plurality of software components is displayed, and a logical component is provided to a user. Prompting the user to select a logical component, and for the logical component selected by the user, generating logical design information based on the logical component information including the definition information, and the logical design information and the physical mounting information of the software component. And generating an application based on the application.