JP2003140893A - Device and method for automatically creating user interface program, program and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To automatically create a UI (user interface) program operating a software from a UML specification and an interface program of a system software. SOLUTION: An interface file 40 of a software is created from a class definition drawing 80 in a UML specification, so as to create a XML file 20 designating operation contents and operation object data of UI users obtained from a sequence drawing and a use case drawing 90 in the UML specification. A GUI program automatic creating device 10 uses a GUI template program 30 comprising a template file and a template processing program, so as to embed contents of a signature of an interface method described in the interface file 40 in null parts of the template file on the basis of operation contents and operation objects described in the XML file 20 according to the commands of the template processing program, and automatically create the GUI program.

Description

Detailed Description of the Invention

[0001]

TECHNICAL FIELD The present invention relates to a UML (Unified Modeling Language) for designing system software.
Relates to a user interface program automatic generation device and an automatic generation method for automatically generating a UI (user interface) program for operating the system. The present invention is useful for system software development.
It is assumed to use rprise Java Beans. Here, JAVA (registered trademark) is an object-oriented programming language developed by Sun Microsystems, Inc. of the United States. (Features of Enterprise Java Beans) Enterprise Java Bea
“Ns” (hereinafter sometimes abbreviated as “EJB”) is the name of a system software platform that is widely used at present. In recent years, a lot of software is
Developed on rise Java Beans. The present invention utilizes the features of Enterprise Java Beans described below. 1. On the Enterprise Java Beans platform, system software is composed of a combination of software parts called components. 2. Enterprise Java Beans components include:
Entity Bean that represents the data itself (Entity Bea
n) and Session Bean that operates a series of data on those Entity Beans. And these beans are represented as classes. 3. In order to utilize these component software, the source code of the interface program exists in each component, and the UI programmer can refer to them.

To take advantage of these features, the present invention provides
It is assumed that the system software will be developed on the EJB.

[0003]

2. Description of the Related Art The conventional UI program for operating system software has been developed in the following procedure. First, design system software in UML or the like. Then, using the function of the UML design software, the original interface program of the system software is output from the class definition diagram of the UML design document. The programmer has a UI for operating the system functions based on these original interface files and the operation contents of the actor described in the UML design document.
To develop from scratch.

[0004]

The conventional UI interface development method for system software has the following problems.

(1) A sequence diagram of a UML design document in which the programmer determines which data is desired to be displayed on the screen because each actor operates the management system in which situation and is updated as a result. , And it is necessary to read and understand the generated interface file and develop the program for each actor by hand.

(2) When a UML design document is changed once the program has been developed, it is necessary for each programmer to manually reflect the design change of the UML design document in the program under development. .

It is an object of the present invention to provide a user interface program automatic generation device capable of automatically generating a user interface program for operating the system software from a UML design document and the interface program.

[0008]

In order to achieve the above object, a user interface program automatic generation method of the present invention is a UML for designing system software.
A user interface program automatic generation method for generating a user interface program by changing a design document and an original interface program generated from the UML design document, the interface file of software from the class definition diagram of the UML design document. And a step of generating user interface user operation contents and operation target data obtained from the sequence diagram and use case diagram of the UML design document, and a user interface template process including a template file and a template processing program. Using a program, the content of the signature of the interface method described in the interface file is displayed in the template based on the operation content and the operation target data. The blank portion of the file, by embedding according to the instructions of the template processing program,
Generating a user interface program for the user interface user to operate.

According to the present invention, the operation contents of the UI user (actor) described in the UML design document of the software, the software interface program output from the UML design document, and the user interface template processing program are provided. By using it, the user interface program can be automatically generated.

Further, another user interface program automatic generation method of the present invention further comprises a step of wrapping before and after a customizable part in the program with tags to which a unique ID is added. Generating a user interface program using the interface template processing program,
A UI that is regenerated when there is a change in the UML design document
For the part surrounded by the tag to which the unique ID is added in the program, the method further includes the step of inheriting and using the source code of the old program.

According to the present invention, the source code of the old program is inherited as it is with respect to the portion surrounded by the tag to which the unique ID is added.
Even if there is a design change in the UML design document, the effect of the design change can be reflected in the program under development with a minimum load.

In another method of automatically generating a user interface program of the present invention, the user interface program may be a graphical user interface program.

[0013]

BEST MODE FOR CARRYING OUT THE INVENTION Next, embodiments of the present invention will be described in detail with reference to the drawings.

In one embodiment of the present invention, a GUI (graphical user interface) program is used as a user interface program in the following description, but the present invention is not limited to this, and a CUI (character・ User interface)
The same can be applied to the case of generating another user interface such as a program.

First, the GUI program automatic generation apparatus 10 according to the embodiment of the present invention is used to generate a GUI from a UML design document.
FIG. 1 shows a flow of processing for generating the program 50 and further improving the GUI program 50 according to individual circumstances.

1) First, class definition diagram of UML design document
From 0, the source code 40 of the interface of the class that constitutes the system to be developed is automatically generated. This technique is a known technique.

2) Next, a set of interfaces operated by a UI user (actor) described in the use case diagram of the UML design document, the sequence diagram 90, etc., and the data changed / affected by the operation. The content is XML
It is output to the outside in the format of the file 20 or the like. This technique is also a known technique.

3) Then, the GUI program automatic generation device 10 automatically generates the GUI program 50 using the XML file 20, the GUI program template 30, and the interface source code 40.
At this time, the base GUI program template 3
Specify 0. By changing this template, various user interface programs such as GUI programs and CUI programs can be created. As the UI, GUI and CUI are generally used.
By using the present invention, it is possible to support a new UI.

4) The generated GUI program 50 can be customized to generate an improved GUI program 60 according to individual needs.

5) When the specification of the original UML design document is changed, it can be reflected in the customized GUI program 60.

Next, UML of the network management system
The basic idea for automatically generating a GUI program from a design document will be described below.

The system software on the EJB platform is an entity bea that represents the data on the system.
It consists of a combination of n and a Session Bean that controls on the system. Therefore, a GUI program for operating such a system, as shown in FIG.
The control unit 51 is a part that controls the system by calling the ssion bean, and the display part 52 is a part that displays the contents of the entity bean to the user.

Session to be called as shown in FIG.
The combination of Bean and affected Entity Bean is U
Since it is decided when designing by ML, it can be obtained from the design information of the UML design document. It is a gist of the present invention to automate the generation of the UI program by utilizing this information.

U generated from the design information of the UML design document
As shown in FIG. 3, I is divided into a part for prompting the user to input data and displaying data and a part for accessing the system software.
Then, basically, the developer adapts the UI program to his needs by customizing the screen display portion. An advantage of the present invention is that a UI program that operates for the time being can be automatically generated, and an approach can be taken in which it is gradually modified to improve the development efficiency, and the UI program developer can develop only the display part. You can devote yourself and not have to be involved in access to system software, and U
When there is a change in the ML design document itself, it is possible to incorporate the design change into the UI program already under development.

FIG. 4 is a block diagram showing the configuration of the GUI program automatic generation apparatus 10 of this embodiment. The GUI program automatic generation device 10 of the present exemplary embodiment includes a list list acquisition unit 11 and an interface information acquisition unit 12.
And a program generation unit 13 and a program combination unit 14.

Next, the flow of processing for automatically generating a GUI program by the GUI program automatic generation apparatus 10 of the present embodiment will be described with reference to the flowchart of FIG.

First, the list list acquisition unit 11 lists a session bean and a method of the session bean that the user accesses using the GUI program from the XML file 20 generated from the UML design document, and the session bean.
A list of a list of Entity Beans that the user wants to display is acquired in association with the operation of an (step 101). Next, the interface information acquisition unit 12 finds the source code 40 of the interface of each class generated based on the UML design document from the list of the Session Bean and Entity Bean classes obtained in step 101, and generates the same. It is loaded into a program, and preparations are made to generate a program for accessing these interfaces (step 102). Next, the program generation unit 13 uses the GUI template program 30 to generate a program for accessing these Session Bean and Entity Bean (step 103).
Finally, the program combining unit 14 combines the newly generated GUI program with the GUI program 70 that has been created and improved in the past, when the GUI program for the same purpose has already been generated in the past. ,
Generate a new GUI program 50 (step 10)
4).

FIG. 6 shows a mechanism for automatically generating a program using a template, which is performed in step 103 in the flowchart of FIG. GUI
The template program 30 is composed of a GUI template file which is a base of the generation program and a template processing program which gives an instruction as to which pattern the template is to be developed. In step 103,
Which Session Bean is the GUI program already generated
To access those Session Beans and Entity Beans, at the same time that we already know (Stage 1) which Entity Beans we want to access and the results can be seen by the user by viewing which Entity Beans. The interface is clear (stage 2). Therefore, in accordance with these pieces of information, the template processing program is displayed on the display unit 31 of the GUI template program 30.
Iteratively expand a part of the above for the number of methods that the Session Bean calls, and make changes according to the interface specifications of each method. Further, the display part of the template file is repeatedly expanded by the number of types of entity beans to be displayed in the UI program, and the generation program is modified according to the interface specifications of each entity bean.

Unique IDs are given to the respective processing parts of the GUI program generated in this way, and these are in the form of start / end tags as shown in FIG.
It is embedded in the source code as a comment. If the programmer customizes only during this comment of the generated program, if there is a design change in the UML design document and the GUI has to be automatically generated from it, only the old part will be inherited. The automatically generated program runs immediately, and the operation can be confirmed by gradually changing it in the form of customization, which enables efficient program development.

In order to flexibly incorporate design changes in the UML design document while maintaining the flexibility of customizing the GUI program, the display program part of the Entity Bean has the following four parts for each Entity Bean. It is possible to customize individually.

-Part for resetting the EntityBean display part-Part for newly registering the EntityBean in the UI-Part for deleting the EntityBean from the UI-Selecting the EntityBean in the UI and letting the user select it
Portion to be an argument to Session Bean Next, the GUI program automatic generation device 10 of the present embodiment
The operation will be described in detail using a more specific example.

In the following description, the Entity Bean processing unit of the default UI program merely displays a list of data in a tabular format. However, by customizing this automatically generated program, network configuration information can be used as nodes. Here is an example that has been modified to display as a link.

(1) First, as shown in FIG. 8, from the use case diagram and sequence diagram in the UML design document,
Session bean used by each actor in specific situations
Method list and Entity affected by them
Get a list of beans. This is a known technique. Here, these pieces of information are extracted from the UML design document as an XML file as shown in FIG. This XML file expresses the following information. -In this UI program, createCoreLink, removeCoreLin, f of Session Bean called NetworkConfigMgt
Access the indPath method. -This UI program displays EdgeDevice and Entity Bean called CoreIf on the screen.・ This UI program creates EdgeDevice and
Call the findAll method. -This UI program calls the findAll method of CoreIf. -For the template file and template expansion file of this UI program, use the file specified in XML.

(2) Next, from the UML design document, the required E
Generate the JB interface file. This is a known technique.

(3) Then, the EJB interface file generated by the above process (2),
A GUI program code is automatically generated from the XML file generated by the process (1) and the GUI template file prepared in advance. FIG. 10 shows a part of the template file, and FIG.
1 shows an example in which it is expanded. In this example, Sess
The template that generates the method call program of ion Bean is findP of NetworkConfigMgt Session Bean.
Shows an example applied to the ath method.
In addition, here, the tag part that the template expands is <% = t
It is indicated by ag # name%>. For example, in the template, <%
= session # method%> is replaced with findPath. The template expansion program has a function of expanding a specific part of the template a specified number of times. For example, the template “///////////////// ＠ session # a
rg # gui # field //////////////// ”should be repeated as many times as there are arguments in the findPath method.
Instructed in the template expansion program.

(4) The program generated as described above has a screen as shown in FIG. 12 by default. In other words, the argument for calling the Session Bean is to fetch the data from the dialog box for the time being and display it in the table format on the screen to display the resulting Entity Bean. In order to display this on the screen shown in FIG. 13, first, the display program part of the Entity Bean is customized. For example, EdgeDe
The program to display vice on the screen is generated as shown in Fig. 14, but here, startId = ”registerEdge
By customizing the part surrounded by “Device” and endId = “registerEdgeDevice” as shown in FIG. 15, the screen of FIG. 12 is changed to the screen as shown in FIG.
As shown in FIG. 6, even if the UML design document is changed, the customized program is automatically generated and the GUI program is automatically maintained while the designated ID is maintained. It is possible to create a program that can withstand.

Although not shown in the figure, the user interface program automatic generation device of this embodiment is
The recording medium includes a recording medium for recording a program for executing the user interface program automatic generation method described above. This recording medium may be a magnetic disk, a semiconductor memory or another recording medium. This program is read from the recording medium to the user interface program automatic generation device and controls the operation of the user interface program automatic generation device. In particular,
CP in user interface program automatic generation device
The above processing is realized by U instructing the hardware resource of the user interface program automatic generation device to perform a specific processing under the control of this program.

In the present embodiment, the operation contents of the user interface user and the operation target data are described as being transmitted using an XML file, but the present invention is not limited to such a case. Any method may be used as long as the operation content and the operation target data can be transmitted.

[0039]

As described above, according to the present invention,
It is possible to obtain the effect that a user interface (hereinafter referred to as UI) program for operating the software can be automatically generated from the UML design document of the system software.

[Brief description of drawings]

FIG. 1 shows a flow of processing for generating a GUI program 50 from a UML design document by using a GUI program automatic generation device 10 according to an embodiment of the present invention, and further improving the GUI program 50 according to individual circumstances. It is a figure.

FIG. 2 is a diagram for explaining the configuration of a GUI program.

FIG. 3 is a diagram for explaining a configuration of a UI generated from design information of a UML design document.

FIG. 4 is a block diagram showing a configuration of a GUI program automatic generation device 10 according to an embodiment of the present invention.

5 is a flowchart showing an operation of the user interface program automatic generation device of FIG. 1. FIG.

6 is a step 103 in the flowchart of FIG.
It is a figure which shows the mechanism of the automatic generation of the program using a template performed in.

FIG. 7 is a diagram illustrating a process of customizing a generated GUI program to be a regenerated program.

FIG. 8 is a diagram illustrating a process of extracting a method list of Session Beans used by each actor in a specific situation and a list of Entity Beans affected by them from a use case diagram and a sequence diagram in the UML design document.

FIG. 9 is a diagram showing an example of an XML file extracted from a UML design document.

FIG. 10 is a diagram showing a part of a template file of automatically generated GUI program code.

FIG. 11 is a diagram showing an example in which a program code of an automatically generated GUI is expanded.

FIG. 12 is a diagram showing a screen that an automatically generated program has as a default.

13 is a diagram showing a screen obtained by customizing the screen shown in FIG.

FIG. 14 is a diagram showing a program for displaying Edge Device on a screen.

FIG. 15: startId = ”registerEd of the program of FIG.
It is a figure which shows the program obtained by customizing the part enclosed by "geDevice" and endId = "registerEdgeDevice".

[Explanation of symbols]

10 GUI program automatic generation device 11 List list acquisition section 12 Interface information acquisition unit 13 Program generator 14 Program connection part 20 XML files 30 GUI template program 31 Control unit 32 display 40 interface source code 50 GUI program code 51 control unit 52 display 60 Improved GUI program code 70 Customized GUI program code 80 class definition diagram 90 Sequence diagram, use case diagram 101-104 steps

   ─────────────────────────────────────────────────── ─── Continued front page    (72) Inventor Hiroshi Tojo             2-3-1, Otemachi, Chiyoda-ku, Tokyo             Inside Telegraph and Telephone Corporation F-term (reference) 5B076 DC01 DD00 DD04 DD05 DD08                       DF06 DF08                 5E501 AA02 AC10 AC34 BA05 CA02                       DA05 DA16 EB15 EB17 FA43

Claims (12)

[Claims] 1. A user interface program automatic generation method for generating a user interface program by changing a UML design document for designing system software and an original interface program generated from the UML design document, A step of generating a software interface file from the class definition diagram of the UML design document; a step of generating user interface user operation contents and operation target data obtained from the sequence diagram and use case diagram of the UML design document; A user interface template processing program consisting of a template file and a template processing program is used to describe in the interface file based on the operation content and the operation target data. Generating a user interface program for the user interface user to operate by embedding the content of the signature of the interface method in the blank portion of the template file according to the instruction of the template processing program. Program automatic generation method. 2. The method further comprises the step of surrounding the customizable part in the program with tags to which unique IDs are added, and generating the user interface program using the user interface template processing program. The step is a UI that is regenerated when there is a change in the UML design document
The automatic generation of a user interface program according to claim 1, further comprising the step of using the source code of the old program by taking over the source code of the program, for the portion surrounded by the tag to which the unique ID is added. Method. 3. The method for automatically generating a user interface program according to claim 1, wherein the user interface program is a graphical user interface program. 4. A user interface program automatic generation device for generating a user interface program by changing a UML design document for designing system software and an original interface program generated from the UML design document, From the UML design document, a list list for obtaining a list of Session Beans that the user accesses using a GUI program and the method of the Session Bean, and a list of Entity Beans that the user wants to display in relation to the operation of the Session Bean. From the list of the list of the Session Bean and Entity Bean classes acquired by the acquisition unit and the list list acquisition unit, the U
An interface information fetching means for finding out the source code of the interface of each of these classes generated based on the ML design document, fetching it into a generation program, and preparing for generating a program that accesses these interfaces, and a user. Program generating means for generating a user interface program for accessing the session bean and the entity bean by using an interface template processing program, and if a user interface program for the same purpose has already been generated, the program generating means Program combining means for combining the user interface program generated by the above and the already generated user interface program to generate a new user interface program, User interface program and an automatic generation system. 5. A UML design document when a user interface template is generated using a user interface template processing program by surrounding the customizable part in the program with tags to which unique IDs are added in advance. If there is a change in the above, the source code of the old program should be taken over and used for the part surrounded by the tag to which the unique ID is added in the regenerated UI program. 5. The user interface program automatic generation device according to claim 4, further comprising: 6. The user interface program automatic generation device according to claim 4, wherein the user interface program is a graphical user interface program. 7. A user interface program automatic generation method for generating a user interface program by changing a UML design document for designing system software and an original interface program generated from the UML design document is executed on a computer. And a process for generating a software interface file from the class definition diagram of the UML design document, and the operation content and operation of the user interface user obtained from the sequence diagram and use case diagram of the UML design document Based on the operation content and the operation target data, a user interface template processing program consisting of a template file and a template processing program is used to generate the target data. A process for generating a user interface program for the user interface user to operate by embedding the content of the signature of the interface method described in the interface file in the blank part of the template file according to the instructions of the template processing program. A program that causes a computer to execute. 8. A computer is caused to further execute a process of enclosing before and after a customizable part in the program with a tag to which a unique ID is added, and the user interface template processing program is used to execute the user interface program. When the UML design document is changed, the process to generate is the UI that is generated again.
8. A process of inheriting and using the source code of an old program is included in a part surrounded by the tag to which the unique ID is added in the program.
The listed program. 9. The program according to claim 7, wherein the user interface program is a graphical user interface program. 10. An automatic generation method of a user interface program for generating a user interface program by changing a UML design document for designing system software and an original interface program generated from the UML design document is executed on a computer. A recording medium for recording a program for causing the user interface user to obtain a software interface file from a class definition diagram of the UML design document, and a user interface user obtained from a sequence diagram and a use case diagram of the UML design document. Using the user interface template processing program consisting of the template file and the template processing program, the operation content and operation target data are generated. A user interface for the user interface user to operate by embedding the content of the signature of the interface method described in the interface file in the blank portion of the template file according to the instruction of the template processing program based on the data A recording medium recording a program for causing a computer to execute the process of generating the program. 11. A computer is caused to further execute a process of enclosing before and after a customizable part in the program with a tag to which a unique ID is added, and the user interface template processing program is used to execute the user interface program. When the UML design document is changed, the process to generate is the UI that is generated again.
2. The process of using the source code of an old program by taking over the source code of the old program is included in the part surrounded by the tag to which the unique ID is added in the program.
0 recording medium. 12. The recording medium according to claim 10, wherein the user interface program is a graphical user interface program.