JP2005070831A - Program generator, program generating method, program, and recording medium - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To easily define image transition even in a large-scaled system, by only grasping only a relation between a button and a transition-destination screen in two successive screens without requiring all the conditions in a system and all the screen names under the conditions to be grasped, and to easily develop the system to shorten a development period without lowering readability for the whole system. <P>SOLUTION: A code generation part is characteristically structured to generate "a first program for generating and displaying the screen constituted of a plurality of components" and "the second program for controlling the screen transition by an event indicating that the component is indicated", based on definition information (definition of a plurality of data items, definition of arrangement of the respective data items onto a database, definition of the screens by the plurality of components including the component corresponding to the data items, and definition information capable of defining the transition-destination screen when the component for the screen is indicated) defined in an input/output table 109. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a web application development support system, and relates to a program generation apparatus, a program generation method, a program, and a recording medium that can efficiently develop screen transitions by button selection.
[0002]
[Prior art]
Web application software that processes core business of a company has many screens due to its multi-functionality, and business programs are executed while changing screens according to processing. There is a need for a mechanism that efficiently develops transitions.
[0003]
Conventionally, in 4GL (Fourth Generation Language) and card-type databases, it is necessary to create a code to control the state of each screen and to correspond to the screen and database items on a one-to-one basis. It was difficult to handle accompanying screen transitions and incidental data not stored in the database.
[0004]
On the other hand, in the “interactive software construction / drive device” disclosed in Japanese Patent Application Laid-Open No. 11-282658 (Patent Document 1), a state transition table is changed from a state transition table in which a state transition definition including a description about a screen name is described. A method has been proposed in which a generation class is automatically generated and input to a state transition management module to control the screen state transition by the state transition table, and the screen display is controlled based on the state transition.
[0005]
This is because the screen state management can be easily realized by describing the screen name in the state transition definition, that is, by incorporating the screen transition into the state transition framework. It was possible to contribute to efficiency improvement.
[0006]
[Patent Document 1] Japanese Patent Laid-Open No. 11-282658
[0007]
[Problems to be solved by the invention]
However, in a large-scale system, there are a considerable number of states to be defined, and it is very difficult to grasp all of these states and screen names in those states.
[0008]
Moreover, even if all these states and the screen names in the states can be grasped, managing all of these states and screen names in the state transition definition table as shown in the above-mentioned Patent Document 1 There was a problem that readability was lowered, maintenance was poor, and errors were likely to occur.
[0009]
The present invention has been made to solve the above-described problems, and an object of the present invention is to define a plurality of data items, a definition of the arrangement of each data item in a database, and the data items. Definition information (input / output table) that can define the screen definition by a plurality of components including the component to be processed and the transition destination screen when the component of the screen is specified is created in advance. Based on the information, “a first program that generates and displays a screen composed of the plurality of components” and “a second program that controls screen transition by an event indicating that the component is instructed” are generated. By doing this, it is not necessary to know all the states in the system and all the screen names in that state, and only the relationship between the button and the transition destination screen is understood between two consecutive screens. It is possible to easily define screen transitions even in a large-scale system, and system development can be easily performed without reducing the readability of the entire system, and the development period can be shortened. A program generation apparatus, a program generation method, a program, and a recording medium are provided.
[0010]
[Means for Solving the Problems]
According to a first aspect of the present invention, in a program generation device that generates a web application program, a screen definition by a plurality of components and a transition destination screen when the component is instructed to the component of the screen Storage means (input / output stored in the external storage device 104 shown in FIG. 1) that stores first definition information (6 column key type = 11 transition screen ID of data item “T”) Based on the table 109 (FIGS. 5 and 6)) and the first definition information stored in the storage means, “a first program for generating and displaying a screen composed of the plurality of components (see FIG. 10). Display program) ”and“ second program for controlling screen transition by an event indicating that the component is designated (screen transition program shown in FIG. 10) ” (Code generation unit 107 shown in FIG. 1, Step 1002 (FIG. 19 in FIG. 10, FIG. 20), Step 1005 (FIG. 18)) and having a.
[0011]
According to a second aspect of the present invention, the storage means includes second definition information (five columns of IO classification = “F”) including definitions of a plurality of data items and definitions of arrangement of the data items in the database. Data item) ”, and the screen component includes a component corresponding to the data item (IO column of 5 columns =“ DI ”or“ DO ”data item). Features.
[0012]
According to a third aspect of the present invention, the generation means “a third program (a session variable shown in FIG. 10) that delivers predetermined information to the transition destination screen by an event indicating that the component has been instructed. Operation program or Java (registered trademark) Script) ”(the code generation unit 107 shown in FIG. 1, Step 1005 in FIG. 10 (Steps S506 and S507 in FIG. 18), or Step 1002 in FIG. 10 (Step S606 in FIG. 20). , S607).
[0013]
According to a fourth aspect of the present invention, the storage means includes third definition information (six columns) that associates a data item to be transferred to the transition destination screen when the component is instructed to the component of the screen. It also stores the item number shown in the processing function of the 7th column of the data item of the key type = “T”, or the data item itself of the 6th column type = “T” (IO classification = “DO”)). And the predetermined information is information corresponding to a data item associated with the component by the third definition information.
[0014]
In a fifth aspect of the present invention, the third program (the session variable operation program shown in FIG. 10) transfers the predetermined information to the transition destination screen by storing the predetermined information in a session object. It is a program.
[0015]
In a sixth aspect of the present invention, the third program (Java (registered trademark) Script shown in FIG. 10) transfers the predetermined information to the transition destination screen without using the predetermined information. The program is a delivery program.
[0016]
According to a seventh aspect of the present invention, the third program (Java (registered trademark) Script shown in FIG. 10) calls the transition destination screen by designating the predetermined information as a parameter. Is transferred to the transition destination screen.
[0017]
According to an eighth aspect of the present invention, when the data item associated with the constituent element by the third definition information is the constituent element itself (six items of key type = “T” data item IO) When the classification = “DO”), the third program calls the transition destination screen by designating information corresponding to the structural element as a parameter without using a session object. Information corresponding to the IO category of the column = “DO” and the key item of the 6 columns = “T”) is generated as a program for transferring to the transition destination screen.
[0018]
According to a ninth aspect of the present invention, the third program is a program called from a screen generated and displayed by the first program (a Java called from a screen generated and displayed by the display program (JSP) in FIG. 10). (Registered trademark) Script).
[0019]
According to a tenth aspect of the present invention, the generating means, based on the second definition information stored in the storage means, “data corresponding to the data item defined by the second definition information to the database. A “fourth program including processing for storing and processing for obtaining data corresponding to the data item from the database” is generated (code generation unit 107 shown in FIG. 1, Step 1003 in FIG. 10 (FIG. 17)). And
[0020]
According to an eleventh aspect of the present invention, in a program generation method in a program generation apparatus for generating a web application program, a definition of a screen by a plurality of components and a case where the components are instructed to the components of the screen Based on the first definition information that can define the transition destination screen, “the first program that generates and displays the screen composed of the plurality of components”, “the event indicating that the component is instructed” It has a generation process (Step 1002 (FIG. 19, FIG. 20), Step 1005 (FIG. 18) in FIG. 10) for generating a “second program for controlling screen transition”.
[0021]
A twelfth aspect of the present invention is a program for executing the program generation method described in the eleventh aspect.
[0022]
A thirteenth invention of the present invention is characterized in that a program for executing the program generation method described in the eleventh invention is stored in a recording medium so as to be readable by a computer.
[0023]
DETAILED DESCRIPTION OF THE INVENTION
The application development system of the present invention will be described below with reference to the drawings.
[0024]
FIG. 1 is a block diagram showing a configuration of a program generation apparatus showing an embodiment of the present invention.
[0025]
In the figure, reference numeral 101 denotes an input device, which corresponds to a pointing device such as a keyboard or mouse, and business specification information (arrangement of tables and data items in a database and the relationship between data items, that is, under what conditions certain data is It is possible to input information indicating what kind of data is originally obtained.
[0026]
Reference numeral 102 denotes a display device, which is composed of a CRT, LCD, or the like, and can display a business specification information input screen, business specification information input from the input screen, a generated program code, and the like. An external storage device 104 such as a hard disk stores an input / output table 109 for storing input business specification information, generated program codes (JSP code 112, servlet code 113, bean code 114), and the like. To do.
[0027]
A processing unit 103 includes a CPU, a ROM, a RAM, and the like, and is realized by the CPU loading and executing a program stored in the ROM, the external storage device 104, or other recording medium on the RAM. And includes a screen control unit 105, a specification analysis unit 106, and a code generation unit 107.
[0028]
The screen control unit 105 includes a business specification description unit 116 that controls a screen (not shown) of the display device 102 in order to input business specification information from the input device 101.
[0029]
The specification analysis unit 106 performs lexical analysis and grammatical analysis on the business specification information input from the input device 101 or read from the external storage device 104. The code generation unit 107 generates a program code (JSP code 112, servlet code 113, bean code 114) based on the business specification information analyzed by the specification analysis unit 106, and stores the generated program code in the external storage device 104. . Further, the code generation unit 107 creates a database (CREATE) and creates a table (for a database (DB) system (not shown)) based on the business specification information (input / output table 109) read from the external storage device 104. (CREATE TABLE) etc. shall be performed.
[0030]
An overall control unit 108 controls each unit such as the screen control unit 105, the specification analysis unit 106, and the code generation unit 107.
[0031]
FIG. 2 is a diagram showing an example of the entire configuration of a web application system using a servlet, JSP, and Bean generated by the code generation unit 107 shown in FIG.
[0032]
The servlet, JSP, and Bean generated by the code generation unit 107 are arranged on the application server 306 on the server 304 side in an executable state.
[0033]
This Web application system is used by the Web browser 302 from the client 301. By accessing the JSP 309 from the web browser 302, an HTML page is generated and returned to the client 301 side. Then, an HTML page 303 transmitted from the JSP 309 is displayed on the web browser 302.
[0034]
A request from the Web browser 302 is transmitted to the server 304 side via HTTP. The server 304 includes an HTTP server 305 and an application server 306, and the application server 306 includes a servlet and JSP execution environment.
[0035]
When a request is transmitted to the server 304 side, the corresponding servlet 307 is activated according to the request. The servlet 307 requests the corresponding Bean 308 to perform processing. Further, the Bean 308 accesses the database 311 using the DB access object 310, performs business-related processing and data processing, and holds the processing result. The DB access object 310 is a class created as a result of analyzing and designing a business, or an existing class that can be reused.
[0036]
Next, the Bean 308 is passed from the servlet 307 to the JSP 309 and the JSP 309 is called. The JSP 309 refers to the processing result held by the Bean 308, generates an HTML page, and returns it to the client 301 side. Alternatively, the Bean 308 may be directly executed from the JSP 309, an HTML page may be generated by referring to the Bean processing, and returned to the client 301 side. The HTML page 303 returned to the client 301 is displayed on the Web browser 302.
[0037]
The servlet 307 has a role of controlling by connecting requests such as receiving a request from the Web browser 302, processing request to the Bean 308, and calling the JSP 309. The JSP 309 is responsible for the display for outputting the HTML page, and the Bean 308 is responsible for processing related to operations such as access to the database 311. Although it is possible to process a request from the Web browser 302 using only the servlet 307 without using the Bean 308 or JSP 309, the role sharing can be performed by clearly separating each role by using the Bean 308 or JSP 309. It can be grasped concisely.
[0038]
FIG. 3 is a diagram showing a system configuration of a Web server that constitutes an application server of the Web application system generated by the code generation unit 107 shown in FIG.
[0039]
The Web server 400 includes a Java (registered trademark) servlet engine (servlet container) 401 for processing requests from browsers operating on a plurality of client PCs 405 transmitted via the network 404, and a Java (registered trademark). A main program (servlet) 402 for processing a request from a client browser given through the servlet engine 401, and a session object 403 for storing a session variable prepared for the main program 402 to maintain a session for each client. It is made up.
[0040]
The servlet session management function provides a dedicated storage area for each session as a mechanism (session mechanism) that maintains continuity between multiple web pages (between multiple HTTP protocols). Data can be retained as long as possible. Such a storage area is called a session object, and the session object 403 corresponds to this.
[0041]
FIG. 4 is a flowchart showing an example of a first control processing procedure in the program generation apparatus of the present invention, and corresponds to the operation of the overall control unit 108 of the processing apparatus 103 shown in FIG. Note that S101 to S106 indicate each step.
[0042]
The processing apparatus 103 shown in FIG. 1 has an input mode for inputting a business specification (input / output table) for generating a code and a generation mode for generating a program code from the input business specification (input / output table).
[0043]
First, when the overall control unit 108 is activated, in step S101, it is determined whether the mode selected by the operator's instruction from the input device 101 is the generation mode or the input mode, and if it is determined that the input mode has been selected. In step S102, the overall control unit 108 activates the screen control unit 105.
[0044]
In step S103, the activated screen control unit 105 activates the business specification input unit by the business specification description unit 116, displays an input screen (not shown), and generates the application name of the web application to be generated and the business specification from the operator. Accepts item input to an input / output table (details are shown in FIGS. 5 and 6 to be described later), stores the input / output table (FIGS. 5 and 6) in the external storage device 104, and ends the process. To do.
[0045]
On the other hand, in step S101, if it is determined that the mode selected by the operator's instruction from the input device 101 is the generation mode, the process proceeds to step S104, and the overall control unit 108 is based on the application name instructed by the operator. The input / output table (business specification information; details are shown in FIG. 5 and FIG. 6 to be described later) stored in the external storage device 104 is read out, and the specification analysis unit 106 is started to read Analysis and grammatical analysis are performed, and the information is stored in a work area in the RAM or the external storage device 104. The information stored in these work areas is used at the time of code generation processing by the code generation unit 107 activated in the following step S105. It is assumed that the application name is also stored in this work area.
[0046]
Next, in step S105, the overall control unit 108 activates the code generation unit 107, and registers a table for a database system (not shown) based on the input / output table subjected to lexical analysis and grammatical analysis by the specification analysis unit 106. And code generation.
[0047]
In step S106, the overall control unit 108 displays the generated code on the display device 102 according to an instruction from the operator, or a location designated by the user (for example, the external storage device 104 or another network connected to the network). Output processing to be written to the storage device of the apparatus.
[0048]
Each process will be specifically described below.
[0049]
First, a case where the input mode is selected by the operator will be described.
[0050]
When the input mode is selected, the overall control unit 108 activates the business specification description unit 116. As a result, a business specification input screen (not shown) is displayed on the display device 102, and the operator inputs the business specifications from the business specification input screen using the input device 101.
[0051]
The business specifications (input / output table) in the program generation apparatus of the present invention will be described below with reference to FIGS.
[0052]
5 and 6 are schematic diagrams for explaining the business specifications (input / output table) in the program generation apparatus of the present invention.
[0053]
In the figure, one column specifies an item number. Columns 2 and 3 represent the information (business specifications) describing the data item database arrangement and the relationship between the data items, and column 2 represents the data file number for input / output. There is a data item branch number (3 columns) as a field constituting the data file number. If “Button” is specified in the data file number (two columns), this item means that a button with some processing is generated.
[0054]
Column 4 is the data item name, which is the name of the field corresponding to the data item branch number (column 3).
[0055]
The input / output table is composed of file items, display items, and session items, and is identified by five columns of IO classifications. The classification is shown in FIG.
[0056]
As shown in FIG. 7, when the IO classification (5 columns) is “F”, it indicates that the data item branch number is a file item. Specifically, the definition of a plurality of data items used in the generated web application and the definition of the arrangement of each data item in the database are shown.
[0057]
When this IO category (5 columns) is “S”, the data item branch number is data registered in the session object (definition of a data item to be shared among a plurality of pages of the web application. In the case of “D *” (“*” indicates an arbitrary character string), the data item branch number is the display item on the screen. Indicates that
[0058]
Since the scope of the session variable defined by IO classification = “S” is determined by the combination of the application name and the client ID, the attribute name of the session variable is the data item name (file item or display item of the same application). ) Must be present. For example, item numbers 7 to 9 in the input / output table are data item names assigned to session variables, but each data item name exists in the same application data item (item numbers 1 to 3).
[0059]
Further, “D *” indicating a display item on the screen includes “DO” indicating that the data item branch number is a text output item, “DI” indicating that the item is a text input item, There is “DB *” indicating a button item.
[0060]
In addition, in “DB *” indicating that it is a button item on the screen, various processes for the session variable can be specified by specifying a processing function in column 7 to be described later.
[0061]
Furthermore, “DB *” indicating a button item on the screen includes “DB” indicating that the button item has no business processing attribute, “DBNinyo” indicating that the button item has an authentication processing attribute, There is “DBTsuika” or the like indicating an additional processing attribute.
[0062]
For example, as shown in item number 6, when a login button generated by specifying “DBNinyo” is designated, the servlet moves through the data file “Login” indicated by the reference data file number in the ninth column. Search is performed, and authentication processing is performed using both “UsrID” and “PassWd” indicated by the reference data item branch number. Then, a message alert indicating the authentication result ("authentication was successful" / "user ID is not registered" / "password is wrong") is generated, and only if the authentication result is OK Proceed to processing.
[0063]
Also, as shown in item number 30, when a login button generated by designating “DBTsuika” is designated, the servlet uses a reference data file number in 9 columns based on the information acquired from the web browser. An additional process of additionally updating the indicated data file “Ordr” is performed. Then, the process proceeds to the next process only when the addition process result is OK, and the message alert is generated when the addition process result is NG. Note that these messages may be defined by a message table or the like.
[0064]
Column 6 shows the type of search key for the data item, and its classification is shown in FIG.
[0065]
As shown in FIG. 8, when the key type (6 columns) is “K”, it indicates that the data item branch number is a primary key (primary key).
[0066]
Further, when the key type (6 columns) is “T”, it indicates that there is a screen transition when the display item of the screen corresponding to the data item branch number is instructed. As a result, the definition of the button that causes the screen transition and the name of the transition screen (application program) when the defined button is pressed can be defined within the framework of the business specification.
[0067]
Column 7 represents the type of processing function for the data item, and its classification is shown in FIG.
[0068]
As shown in FIG. 9, when the processing function (seven columns) is “S”, it indicates that a session variable is operated, and the operation contents of the session variable are described in eight columns.
[0069]
For example, in the case of item number 6, the contents of parentheses on the left side represent a set of session variables for which values are set, and the parentheses on the right side indicate sets of input / output item numbers for setting values. When the button generated by this definition is designated, the servlet assigns the values (user ID, name, password) of the item numbers 1, 2, and 3 to the session variables (user ID, name, password) of item numbers 7, 8, and 9. Password).
[0070]
Also, as in the case of item number 21, when the processing formula is described in a format such as “IF (first term, second term, third term)”, the button generated with this definition is indicated. Then, the servlet executes the arithmetic expression of the second term when the result of the arithmetic expression of the first term is “true”, whereas the servlet executes the third when the result of the arithmetic expression of the first term is “false”. Execute the arithmetic expression of the term and manipulate the session variable. In addition, what is described as “−” in the arithmetic expression indicates that the process does nothing.
[0071]
That is, when “number (item number 20)> 0”, the product code (item number 18), the product name (item number 19), and the number (item number 20) are set as session variables (item number 22, item number 23, It is stored (additional update) in item number 24).
[0072]
In other words, these define the storage (setting) timing of the session variable in the session object in association with the button instruction (event occurrence). Further, as described above, these storage timings can be defined for each session variable (one or more can be used).
[0073]
In addition, as shown in the processing function classification list of FIG. 9, when “E” is described in the processing function, the session is explicitly released when the button generated by the definition of the data item is designated. This indicates that processing (processing for deleting the corresponding session variable from the session object) is performed. The release contents of the session variable are described in 8 columns, and the item number of the session variable to be released is described as a set in parentheses. However, “All Off” is described only when all sessions are released.
[0074]
For example, in the definition of the logout button of item No. 34, “E” is specified in the processing function (column 7) and “All Off” is described in the processing formula. Show. When a button generated by this definition (that is, a logout button) is designated, the generated servlet releases all session variables from the system.
[0075]
In addition, in the definition of the order determination button of item number 30, “E” is designated as the machining function, and session variables that are desired to be opened in the machining formula are defined in pairs. In this definition, the sessions of item numbers 22, 23, and 24 are released.
[0076]
That is, these define the timing for deleting (releasing) the session variable from the session object in association with the button instruction (event occurrence). Further, as described above, these timings can be defined for each session variable (one or more can be used).
[0077]
When the timing for deleting (releasing) all session variables has been defined (when “All Off” is described in the processing formula), the timing for invalidating (releasing) the session object itself (for event occurrence) The definition of (corresponding timing) shall be shown.
[0078]
Although not shown in FIGS. 5 and 6, the timing at which the session object itself is invalidated (released) may be defined in association with the access interval from the client. That is, it may be configured to set a time for timeout when the client does not access for a predetermined time. The timeout time may be set in the input / output table shown in FIGS. 5 and 6 or in another setting file.
[0079]
Next, the 9th and 10th columns indicate the reference destination data file number and the reference destination data item branch number. When “DBNinyo” is specified in the IO classification (5 columns), the authentication process is performed. The data file number and the data item branch number to be used are shown in the reference destination data file number (9th column) and the reference destination data item branch number (10th column).
[0080]
When “DBTsuika” is specified in the IO classification (5 columns), the data file number used in the additional processing is shown in the reference data file number (9 columns).
[0081]
Furthermore, when “DO” is specified in the IO category (5 columns) and “T” is specified in the key function (6 columns), the data value corresponding to the data item is displayed on the transition destination screen. Passed as a passing parameter. In addition, when passing parameters at the time of screen transition, it is a common technique to implement using session variables, but setting a session variable to achieve only one screen transition is a session It is not the essence of variables. Therefore, in such a case, it is possible to define passing of parameters between screens without explicitly defining session variables, that is, without causing the server to maintain a session. Note that screen transition and parameter transfer at this time are performed by Java (registered trademark) Script. As described above, only when the transition destination screen is defined in the display item of the data item (IO category = “DO”), the data can be transferred between the screens without explicitly defining the session variable. it can. Therefore, it is possible to easily generate an optimum web application desired by the user by freely using data transfer using a session between a plurality of screens and data transfer not using a session.
[0082]
The eleventh column is a transition destination screen ID, and when “T” is specified in the key function (sixth column), the transition destination screen ID is displayed.
[0083]
Column 12 is the screen ID, column 13 is the screen name, and indicates the screen ID and screen name.
[0084]
The 14th column is a screen attribute indicating the business processing attribute of the screen. As this screen attribute, there is “Kensaku” for performing a search process to the database using the data file number specified by the target data file number in the 15th column. When a parameter is specified when the screen is called, the search process is performed using the parameter as a search condition. When “Session” is designated by the target data file number in the 15th column, the session variable is searched for instead of searching for the database.
[0085]
The input / output tables shown in FIGS. 5 and 6 are stored in the external storage device 104 in association with an application name (for example, “SyohinTymon”) input from a business specification input unit (not shown). .
[0086]
Although not shown in FIGS. 5 and 6, the timeout time of the session object (time for ending the session when the client access is not performed for a certain period of time) is shown in FIGS. It may be configured to be settable in an input / output table or a setting file (not shown).
[0087]
In the present embodiment, the input / output table shown in FIGS. 5 and 6 has been described as being input from an input screen (not shown). However, the input / output table is configured by a text file, CSV file, etc. It may be configured to be created by an editor or other application and stored in the external storage device 104.
[0088]
FIG. 10 is a schematic diagram showing the concept of the program generation process (process configuration) in the program generation apparatus of the present invention.
[0089]
Of the information in the input / output table 109 shown in FIGS. 5 and 6, a database (DB) is created and a table is created from a data file whose IO classification is “F” (Step 1001 (corresponding to FIG. 16 described later)). ).
[0090]
For example, a database is created (CREATE) with an application name (input from a user interface (not shown)), and the table name is set to “Login” from the item numbers 1 to 3 shown in FIGS. , A table is created in which each item in the table is “UsrID”, “Name”, and “PassWd”.
[0091]
Further, display program code is generated by JSP and Java (registered trademark) Script from the data file whose IO classification is “D *” (Step 1002 (corresponding to FIGS. 19 and 20 described later)). Specifically, data corresponding to a data item whose IO category is “DI” is input from the client, and display program code for generating data corresponding to a data item whose IO category is “DO” is generated to the client. Do.
[0092]
Further, a data operation program code for the database (DB) is created from the data file whose IO classification is “F” (Step 1003 (corresponding to FIG. 17 described later)). Specifically, the data operation of the data processing corresponding to the data item whose IO classification is “F” in the database (new / addition processing), the data acquisition processing (search processing) corresponding to the data item from the database Generate program code.
[0093]
Also, a program code for performing business processing is created from a data file whose IO classification is “DB *”.
[0094]
Further, a program code for performing a session variable operation is created from a data file whose IO category is “DB *” and processing function is “S” or “E” and a data file whose IO category is “S”. Specifically, the information corresponding to the data item (session variable) whose IO category is “S” shown in the processing formula of the data item (button) whose IO category is “DB *” and whose processing function is “S”, Processing for storing (setting) in the session object at the timing when the button is instructed (timing for occurrence of the button pressing event), and processing formula for the data item (button) whose IO classification is “DB *” and whose processing function is “E” The process of deleting (releasing) the information corresponding to the data item (session variable) whose IO classification is “S” from the session object at the timing when the button is instructed (the generation timing of the button press event) (note that When the processing expression is “All Off”, a session variable operation program for invalidating (releasing) the session object itself. Generate the program.
[0095]
In addition, a program code for performing a screen transition process is created from a data file having an IO classification “DB *” and a key function “T”. The business processing program, session variable operation program, and screen transition program of Step 1004 described above correspond to FIG.
[0096]
Only when the IO category is “DO” and the key function is “T”, the data item data is designated as a parameter to be passed to the transition destination screen by an event indicating that the display item of the data item is instructed. Then, a Java (registered trademark) Script code for calling the transition destination screen is created (corresponding to steps S606 and S607 in FIG. 20 described later). This makes it possible to automatically generate a screen display program (JSP) and a screen transition action program (Java (registered trademark) Script called by JSP) that do not use session variables.
[0097]
As described above, screens are associated with database items, transition screens are defined for each screen, and program codes are automatically generated from business specifications and business logic definitions for complex condition judgments and incidental data handling. be able to.
[0098]
10 is a conceptual diagram, and details are shown in flowcharts of FIGS. 15 to 20 described later.
[0099]
Hereinafter, the web application program generated based on the input / output tables shown in FIGS. 5 and 6 will be described specifically and in detail with reference to FIGS.
[0100]
FIGS. 11-14 is a schematic diagram which shows an example of the web application produced | generated in the program production | generation apparatus of this invention.
[0101]
The item numbers 1 to 3 of the input / output tables shown in FIGS. 5 and 6 indicate that the table name is “Login”, the item names in the table are “UsrID”, “Name”, “PassWd”, and “UsrID” is It is defined that a table as a primary key is created for a database system (not shown).
[0102]
Item numbers 4 to 6 define that a code for controlling the display and processing of a login screen 1100 as shown in FIG. 11 is generated.
[0103]
Specifically, item numbers 4 and 5 define the generation of labels 1101 and 1102 and text boxes 1103 and 1104 for inputting a user ID (UsrID) and a password (PassWd).
[0104]
Item No. 6 is authentication using the user ID (UsrID) and password (PassWd) of the database ("Login" table) shown in column 9 because "DBNinsho" is specified in the IO column of column 5. After processing, the values of Nos. 1, 2, and 3 are entered into the session variable object defined in Nos. 7, 8, and 9 based on the 8 columns of processing formulas (stored in the session object as session variables) “Login” has a function of transitioning to the shopping cart screen 1200 shown in FIG. 12 (that is, when the authentication process ends normally, the user information is maintained as a session variable and transitioning to the shopping cart screen 1200). "Button 1105 is defined to be generated.
[0105]
In this authentication process, the database ("Login" table) is searched using the primary key (user ID) input from the login screen, and the user ID and password registered in the database are acquired and input. If the user ID is not registered in the database, or if the entered password and the registered password are not equal, an alert display (not shown) is displayed. On the other hand, if the entered password and the registered password are equal, 1106 is displayed. Such a display is performed, and the process proceeds to the next process.
[0106]
Item Nos. 10 to 13 are tables in which the table name is “ShohinM”, the item names in the table are “ShohinCode”, “ShohinName”, “ShohinTanka”, “ShohinSetsumei”, and “ShohinCode” is the primary key. It is defined to create a database system (not shown).
[0107]
Item numbers 14 to 17 define that a code for controlling the display of a merchandise master (ShohinM) screen 11204 as shown in FIG. 12 is generated. In this product master screen 1204, since “Kensaku” is specified as the screen attribute of the 14th column, the 15th column database (“ShohinM” table) is searched (when a parameter is specified, the parameter is designated as a key). And a process for displaying a list of the search results is defined.
[0108]
Specifically, the item numbers 14, 15, 16, and 17 generate codes for displaying a list of search results of the product code (ShohinCode), the product name (ShohinName), the unit price (ShohinTanka), and the description (ShohinSetsumei). Is defined.
[0109]
The item numbers 18 to 21 define that a code for controlling the display of a shopping cart screen 1200 as shown in FIG. 12 is generated. In this shopping cart screen 1200, since “Kensaku” is specified in the screen attribute of the 14th column, the database (“ShohinM” table) shown in the 15th column is searched (when a parameter is specified, the parameter is specified). And a process for displaying a list of the search results is defined.
[0110]
Specifically, item numbers 18 and 19 define that a code for displaying a search result of a product code (ShohinCode) and a product name (ShohinName) is generated. Item No. 20 defines that a text box for inputting the number (Kosu) is generated. Furthermore, the item number 21 is a session variable object in which the values of the item numbers 18, 19, and 20 are defined by the item numbers 22, 23, and 24 when the value of the item number 20 is positive based on the 8-column processing formula. And “To Order” button 1202 for transitioning to the order content confirmation screen (kakuun) is defined to be generated. In addition, the product code shown in Item No. 18 indicates that the product is indicated by instructing this display with a mouse or the like because the IO classification in the 5th row is “DO” and the key function in the 6th row is designated as “T”. Transition to the master (ShohinM) screen 1204 is defined. At this time, the product code is passed to the product master screen 1204 as a parameter.
[0111]
Item numbers 25 to 30 define that a code for controlling the display processing of the order confirmation screen (Kakuunin) 1300 and the order confirmation screen as shown in FIG. 13 is generated. In this order confirmation screen, “Kensaku” is specified in the screen attribute of the 14th column, so the session variable object (Session) shown in the 15th column is searched (when a parameter is specified, the parameter is keyed) And a process for displaying a list of the search results is incorporated.
[0112]
Specifically, item numbers 25, 26, and 27 define that a code for displaying a search result of a product code (ShohinCode), a product name (ShohinName), and the number (Kosu) is generated. The item number 28 opens the session variable object defined in the item numbers 22, 23, and 24 based on the eight columns of processing formulas (deletes the session variable from the session object), and the shopping shown in FIG. It is defined that a “cancel all” button 1201 for transitioning to a cart screen 1200 is generated. Further, item number 29 defines that a “Continue Shopping” button 1302 for transitioning to a shopping cart screen 1200 is generated. In addition, item number 30 is registered after the contents of this order confirmation screen are registered in the database ("Order" table) shown in column 9 because "DBTsuika" is specified in the IO column of 5 columns. , Based on the processing formulas in 8 columns, release the session variable object defined in the item numbers 22, 23, 24, and generate an “order determination” button 1303 for transitioning to the logout screen shown in FIG. Is defined.
[0113]
In addition, items 31 to 33 are created in the database with a table name “Order”, each item name in the table “UsrID”, “ShohinCode”, “Kosu”, and “UsrID” as a primary key. Is defined.
[0114]
Further, item numbers 34 and 35 define that a logout screen 1400 as shown in FIG. 14 is generated.
[0115]
Specifically, the item number 34 releases all session variable objects based on the processing formula (All Off) (invalidates the session object itself), and transitions to the login screen (Login) 1100 shown in FIG. It defines that a “logout” button 1401 is generated.
[0116]
The item number 35 defines that a “shopping” button 1402 for transitioning to the shopping cart screen (Cart) 1200 shown in FIG. 12 is generated.
[0117]
As described above, the application generated based on the input / output tables shown in FIGS. 5 and 6 is activated when the JSP corresponding to the login screen 1100 shown in FIG. 11 is started from the web browser. Is displayed on the client's web browser.
[0118]
Next, when the user ID and password are input to the displayed login screen 1100 and the login button 1105 is instructed, data is transferred to the servlet, authentication processing is executed by the servlet, and authentication is successful. This is notified (notification screen 1106 shown in FIG. 11), and a JSP corresponding to the shopping cart screen 1200 shown in FIG. 12 as a transition destination screen is started. Then, a shopping cart screen is displayed on the web browser of the client. In this shopping cart screen, the user can make a purchase reservation for a product by inputting a numerical value in the quantity column of the displayed product and instructing a “To Order” button 1202.
[0119]
Next, when the product code 1201 is designated on the shopping cart screen 1200, the JSP corresponding to the product master screen 1204 is started in another window by Java (registered trademark) Script (the designated product code is set as a parameter). As a). Then, the product master screen is displayed on the web browser of the client. In this processing, the instructed product code can be passed to the product master screen 1204 without using a session variable, and the details of the product master using the product code as a key can be displayed. For example, in the example of the product master screen 1204, a detailed screen as a result of searching for the product master with the product code “001” is displayed.
[0120]
In addition, when the “Order” button 1202 is instructed on the displayed shopping cart screen 1200, data is transferred to the servlet, and the “Product Code”, “Product Name”, and “Quantity” that are the order contents by the servlet are displayed. Processing for storing data in a session variable is executed, and a JSP corresponding to the order content confirmation screen 1300 shown in FIG. Then, an order details confirmation screen 1300 is displayed on the web browser of the client.
[0121]
In the order content confirmation screen 1300 shown in FIG. 13, the content input on the shopping cart screen 1200 of FIG. 12 is displayed based on the session variable.
[0122]
Next, when the “Cancel All” button 1301 is instructed on the displayed order content confirmation screen 1300, data is transferred to the servlet, and the servlet sets session variables of “product code”, “product name”, and “number”. The opening process is executed, and the JSP corresponding to the shopping cart screen 1200 that is the transition destination screen is activated. Then, the shopping cart screen 1200 shown in FIG. 12 is displayed on the web browser of the client.
[0123]
In addition, when the “Continue Shopping” button 1302 is instructed on the order details confirmation screen 1300, data is transferred to the servlet, and the JSP corresponding to the shopping cart screen as the transition destination screen is activated by the servlet. Then, a shopping cart screen 1200 is displayed on the client's web browser.
[0124]
Further, when an “order determination” button 1303 is instructed on the order content confirmation screen 1300, the data is transferred to the servlet, and the servlet executes an additional update process for the database table Order based on the transferred data. Is successful, processing for releasing the session variables of “product code”, “product name”, and “number” is executed, and the JSP corresponding to the logout screen 1400 that is the transition destination screen is activated. Then, a logout screen 1400 shown in FIG. 14 is displayed on the web browser of the client.
[0125]
Next, when a “logout” button 1401 is instructed on the displayed logout screen 1400, data is transferred to the servlet, and processing for releasing all session variables is executed by the servlet, and a login screen which is a transition destination screen JSP corresponding to is activated. Then, the login screen 1100 shown in FIG. 11 is displayed on the web browser of the client.
[0126]
In addition, when a “shopping” button 1402 is instructed on the logout screen 1400, data is transferred to the servlet, and the JSP corresponding to the shopping cart screen that is the transition destination screen is activated by the servlet. Then, a shopping cart screen 1200 is displayed on the client's web browser.
[0127]
The above is the basic flow of the application generated based on the input / output tables shown in FIGS.
[0128]
Hereinafter, the code generation process by the code generation unit 107 illustrated in FIG. 1 will be described with reference to the flowcharts of FIGS.
[0129]
FIG. 15 is a flowchart showing an example of the second control processing procedure of the present invention, and corresponds to the code generation processing by the code generation unit 107 shown in FIG. S201 to S204 indicate steps.
[0130]
First, in step S201, a DB system (not shown) is accessed based on the business specification information stored in the input / output table 109, and a database (DB) is created (details are shown in FIG. 16).
[0131]
Next, in step S202, a bean code 114 for performing input data check processing and data operation processing for the database created in step S201 is generated based on the input / output table 109 (details are shown in FIG. 17).
[0132]
Next, in step S203, based on the input / output table 109, the input data from the web browser is acquired and the servlet code 113 for controlling the entire web application is generated (details are shown in FIG. 18).
[0133]
Next, in step S204, a JSP code 112 for controlling the display on the web browser (controlling the output of each screen shown in FIGS. 11 to 14 to the web browser) is generated (details are shown in FIGS. 19 and 20). The process is terminated and the process returns to the flowchart of FIG.
[0134]
FIG. 16 is a flowchart showing an example of the third control processing procedure of the present invention, which corresponds to the DB creation processing shown in step S201 of FIG. S301 to S305 indicate each step.
[0135]
First, in step S301, an application name is acquired from a work area to a DB system (not shown), and a command for creating a DB having the application name as a database name is issued. Next, in step S302, connection is made to the DB created in step S301.
[0136]
In step S303, one data file number of IO classification (5 columns) = “F” defined in the input / output table 109 is acquired from the work area, and the data file number is stored in the table name and the data file number. A SQL statement for creating a table with the data item branch number as the item name in the table is generated, and a query of the SQL statement is executed.
[0137]
Next, in step S304, it is determined whether or not the processing in step S303 has been completed for all data files with IO classification (5 columns) = “F”. If not, the process returns to step S303. On the other hand, if it is determined that the process has already been completed, the process proceeds to step S305.
[0138]
In step S305, a process of disconnecting from the database is performed, the process ends, and the process returns to the flowchart of FIG.
[0139]
FIG. 17 is a flowchart showing an example of a fourth control processing procedure according to the present invention, and corresponds to the business processing bean generation processing shown in step S202 of FIG. In addition, S401-S405 shows each step.
[0140]
First, in step S401, one data file number of IO classification (5 columns) = “F” defined in the input / output table 109 is obtained from the work area, and a business processing bean file corresponding to the data file number is obtained. Is generated. The bean file name is, for example, a bean file in which the data file number and the character string “Bean” are added to the application name and the extension is “java (registered trademark)”. At this time, a declaration of “package name (for example, a data file number and a character string“ Bean ”added to an application name) declaration,“ java (registered trademark). ”And a code for implementing an interface necessary for using Java (registered trademark) Beans” are stored.
[0141]
Next, in step S402, a search processing code is generated. In detail, “Connect to DB (may be configured to use the user ID (UsrID) and password (PassWD) stored in the session variable at this time), and use the specified parameter as the search condition. An SQL statement query for performing a search process on the table corresponding to the data file number is executed, a search result is returned, and a code (search method) for disconnecting from the DB is generated in the Bean file.
[0142]
Next, in step S403, a new / addition processing code is generated. Specifically, “Connect to DB, execute a query of an SQL statement for performing additional processing on the table corresponding to the data file number as the newly added data with the specified parameter, and return the new addition result, A code for disconnecting from the DB (additional method) "is generated in the Bean file.
[0143]
Next, in step S404, a deletion process code is generated. For more details, refer to “Code to connect to DB, execute SQL statement to specify deletion target record by specified parameter and perform deletion process, return deletion result, and disconnect from DB (deletion method) Is generated in the Bean file.
[0144]
In step S405, it is determined whether or not the processing in steps S401 to S405 has been completed for all data files with IO classification (5 columns) = “F”. If not, the process returns to step S401. On the other hand, if it is determined that the process has already been completed, the process is terminated and the process returns to the flowchart of FIG.
[0145]
Note that the code generated in the Bean file by the above steps S402, S403, and S404 includes: "driver class loading process, database connection process, SQL statement object generation process, data passed from servlet" “A process for acquiring a result by executing a query of an SQL statement based on SQL, a process for setting a result, a code for performing a process for closing an SQL statement object and a database connection object”, and the like are described.
[0146]
The search processing code, new / addition processing code, and deletion processing code generated in steps S402, S403, and S404 are business processing classes defined in the Bean file (for example, class name: character string in data file name). The search method, authentication method, add method, and delete method in “DBAccess” are added.
[0147]
Further, in the flowchart of FIG. 17, a configuration is shown in which search processing codes, new addition processing codes, and deletion processing codes are generated for all data files of “F” of the IO classification defined in the input / output table. Only the processing code defined in the input / output table may be generated.
[0148]
For example, in the input / output tables shown in FIGS. 5 and 6, item number 6 defines IO classification (5 columns) = “DBNinsho” and reference data file number (9 columns) = “Login”. The search processing code for the “Login” table of the database is generated. Further, in item numbers 14 to 17, since the screen attribute (14 columns) = “Kensaku” and the target data file number (15 columns) = “ShohinM” are defined, the search processing code for the “ShohinM” table in the database is Generate. Furthermore, since item number 30 defines IO classification (5 columns) = “DBTsuika” and reference data file number (9 columns) = “Order”, an additional processing code for the “Order” table of the database is generated. You may comprise.
[0149]
FIG. 18 is a flowchart showing an example of the fifth control processing procedure of the present invention, and corresponds to the servlet generation processing shown in step S203 of FIG. S501 to S513 indicate each step.
[0150]
First, in step S501, one data file number of IO classification (5 columns) = “D *” defined in the input / output table 109 is acquired from the work area, and the data item corresponding to the button is assigned to the data file number ( If there is no data item corresponding to the button, the process proceeds to step S513 as it is.
[0151]
On the other hand, if it is determined in step S501 that there is a data item corresponding to the button in the data file number, a servlet file is generated in step S502. The servlet file name is, for example, a servlet file in which the data file number and the character string “Servlet” are added to the application name and the extension is “java (registered trademark)”. At this time, at the top of the servlet file, “code to import the Bean package to be used and other necessary packages, access modifier, class definition, inheritance of class (for example, HTTP Servlet class), web browser (HTML form) ”) Is stored in the“ code indicating the method for receiving the parameter (transmission information) transmitted from () ”.
[0152]
Next, in step S503, “a code for receiving transmission information (input information) from the web browser” is generated in the servlet file.
[0153]
Next, in step S504, one data item corresponding to the button in the data file number is acquired, and the data item corresponding to the button is a button with business processing (IO classification (5 columns) is “DBNinsho”, ("DBKensaku", "DBTsuika", "DBSakuzuyo")). If it is determined that the button is not a button with business processing, the process proceeds to step S506.
[0154]
On the other hand, if it is determined in step S504 that the button is associated with a business process, in step S505, “a code for executing the corresponding business process when the button is instructed” is generated in the servlet file. To do.
[0155]
More specifically, when the button is “DBNinsyo”, “when the button is instructed, the reference data file number (9 Execute the search method corresponding to the data file specified in (Column), and perform the authentication process by comparing the search result with the data acquired from the web browser corresponding to the specified reference data item branch number (10 columns) If the authentication fails, a code for terminating the process ”is generated in the servlet file.
[0156]
When the button is “DBKensaku”, “when the button is instructed, the data acquired from the web browser is used as a search condition to the data file specified by the reference data file number (9 columns). Generate code that executes the corresponding search method and retrieves the search results.
[0157]
When the button is “DBTsuika”, “when the button is instructed, the data acquired from the web browser is added to the data file designated by the reference data file number (9 columns) as additional data. Generate code that executes the corresponding additional method ".
[0158]
When the button is “DBSakuzuyo”, “when the button is instructed, the data file specified by the reference data file number (9th column) with the data acquired from the web browser as the data to be deleted. Generate code that executes the delete method corresponding to.
[0159]
Next, in step S506, it is determined whether or not the processing function of the data item corresponding to the button = “S”. If it is determined that it is not “S”, the process proceeds to step S508.
[0160]
On the other hand, if it is determined in step S506 that the processing function (seven columns) of the data item corresponding to the button = “S”, in step S507, although not shown, “Acquire session object (if not present” "Generate code" in the servlet file (not shown), based on the definition of the processing formula (8 columns), "When the button is instructed, the session object to the session variable (specified in the processing formula Generate code to add and update session variables based on the servlet file.
[0161]
Note that to acquire a session object, the getSession () method is used in the create mode. The session variable is set to the session object using the setAttribute () method. Furthermore, in order to refer to a session variable from a session object, a getAttribute () method is used.
[0162]
Next, in step S508, it is determined whether or not the processing function of the data item corresponding to the button is “E”. If it is determined that the processing function is not “E”, the process proceeds to step S510.
[0163]
On the other hand, if it is determined in step S508 that the processing function of the data item corresponding to the button (seven columns) = “E”, in step S509, although not illustrated, “code for acquiring a session object” is set as a servlet. Generated in the file (not shown) and based on the definition of the processing formula (8 columns) “When the button is specified, the attribute in the session object (the attribute corresponding to the session variable specified in the processing formula) Is generated in the servlet file. If it is desired to specify “All Off” in the processing expression, a code for opening (invalidating) the session object of the user is generated.
[0164]
Note that to acquire a session object, the getSession () method is used in the create mode. Also, the removeAttribute () method is used to delete a session variable from the session object. Furthermore, the invalidate () method is used to invalidate the session object itself.
[0165]
Further, “G” indicating other calculation processing is provided in the processing function. For example, when it is determined that the processing function (7 columns) = “G” of the data item corresponding to the button, the processing formula (8 Based on the definition of the column, “a code for executing the arithmetic processing specified by the processing expression when the button is designated” may be generated in the servlet file.
[0166]
Next, in step S510, it is determined whether or not the key type (six columns) of the data item corresponding to the button is “T”. If it is determined that the key type is not “T”, the process proceeds to step S512. .
[0167]
On the other hand, if it is determined in step S510 that the key type of the data item corresponding to the button is “T”, in step S511, “the button is selected” based on the instruction of the transition destination screen ID (11th column). When instructed, a code for calling a JSP corresponding to the transition destination screen is generated in the servlet file.
[0168]
Next, in step S512, it is determined whether or not the processing in steps S504 to S511 has been completed for all the buttons in the data file. If the processing has not been completed, the process returns to step S504. If it is determined, the process proceeds to step S513.
[0169]
In step S513, it is determined whether or not the processing in steps S501 to S512 has been completed for all data files with IO classification (5 columns) = “D *”. If not yet completed, the process returns to step S501. On the other hand, if it is determined that the process has already been completed, the process ends and the process returns to the flowchart of FIG.
[0170]
If the session object timeout time is set in the input / output table shown in FIG. 5 or FIG. 6 or the setting file (not shown), the timeout is set in the servlet file. It may be configured to generate a “code for performing a process for setting to do”.
[0171]
19 and 20 are flowcharts showing an example of the sixth control processing procedure according to the present invention, which corresponds to the JSP generation processing shown in step S204 of FIG. S601 to S615 indicate each step.
[0172]
First, in step S601, one data file number of IO division (5 columns) = “D *” defined in the input / output table 109 is acquired from the work area, and a JSP file corresponding to the data file is generated. As the file name of the JSP file, for example, the data file name is added to the application name and the extension is “jsp”. The JSP file includes “a code for setting the MIME type of the JSP page and a character set to be encoded, a code for instantiating a Bean corresponding to the data file, and an“ html ”tag“ <head><“title> application name </ title>” etc. ”is generated and stored.
[0173]
Next, in step S602, it is determined whether or not there is a data item having IO classification (5 columns) = “DO” and key type (6 columns) = “T” in the data file number. In the case, the process proceeds to step S604.
[0174]
On the other hand, if it is determined in step S602 that there is a data item with IO classification (5 columns) = “DO” and key type (6 columns) = “T” in the data file number, in step S603, “ A new window is displayed, and a Java (registered trademark) Script code for screen transition for accessing a JSP corresponding to the transition destination screen from the window is generated in the JSP file. At this time, the program code is generated on the transition destination screen so as to pass the value of the data item as a parameter to the transition destination screen.
[0175]
Next, after storing the html tag “</ head><body>” and the like, in step S604, it is determined whether “Kensaku” is specified in the screen attribute (14th column) of the data file number. If it is determined that it is not designated, the process proceeds to step S606.
[0176]
On the other hand, if it is determined in step S604 that “Kensaku” is specified in the screen attribute (14th column) of the data file number, in step S605, “Bean is used to execute the search process. Is generated, and the process proceeds to step S606.
[0177]
Next, in step S606, one data item is extracted from the data file number, and whether or not IO classification (5 columns) = “DO” and key type (6 columns) of the data item is “T”. If it is determined that IO classification = “DO” and key type = “T”, the process proceeds to step S608.
[0178]
On the other hand, if it is determined in step S606 that the IO classification (5 columns) = “DO” and the key type (6 columns) = “T” of the data item, in step S607, “output indicating the data item is displayed”. “Code for generating items” is generated in the JSP file. However, when the output item is specified, this code uses the value of the data item as a parameter, specifies the transition destination screen ID (11th column), and activates the above-described Java (registered trademark) Script for screen transition. Generate as follows.
[0179]
Next, in step S608, it is determined whether IO category (5 columns) = “DO” and key type (6 columns) ≠ “T” of the data item, and IO category = “DO” and key type. If it is determined that ≠ “T”, the process proceeds to step S610.
[0180]
On the other hand, if it is determined in step S608 that the IO classification (5 columns) = “DO” and the key type (6 columns) ≠ “T” of the data item, in step S609, “display the data item”. "Code for generating a display output item to be generated" is generated in the JSP file.
[0181]
Next, in step S610, it is determined whether or not the IO category (5 columns) of the data item is “DI”. If it is determined that the IO category is not “DI”, the process proceeds to step S612.
[0182]
On the other hand, if it is determined in step S610 that the IO classification (5 columns) of the data item is “DI”, “code for generating a text box for inputting the data item” is set in step S611. Generate in the JSP file.
[0183]
Next, in step S612, it is determined whether or not the IO category (5 columns) of the data item is “DB *”. If it is determined that the IO category is not “DB *”, the process proceeds to step S614. .
[0184]
On the other hand, if it is determined in step S612 that the IO classification (5 columns) of the data item is “DB *”, “code for generating a button corresponding to the data item” is stored in the JSP file in step S613. Generate within. However, when the button is instructed, the corresponding servlet is activated, and the code is generated so that the form data is transmitted to the servlet.
[0185]
Next, in step S614, it is determined whether or not the processing in steps S606 to S613 has been completed for all data items in the data file. If it is determined that the processing has not ended, the process returns to step S606.
[0186]
On the other hand, if it is determined in step S614 that the processing in steps S606 to S613 has been completed for all data items in the data file, the html tag “</ body></html>” or the like is added. After storing in the JSP file, the process proceeds to step S615.
[0187]
Next, in step S615, it is determined whether or not the processing of steps S601 to S614 has been completed for all data files with IO classification (5 columns) = “D *”, and if it is determined that the processing has not ended. Returns to step S601.
[0188]
On the other hand, if it is determined in step S615 that the processes in steps S606 to S613 have been completed, the process ends and the process returns to the flowchart in FIG.
[0189]
In this flowchart, as shown in steps S606 and S607, when it is determined that the IO category (5 columns) = “DO” and the key type (6 columns) = “T” of the data item, the data item is In the above description, the code is generated so that the Java (registered trademark) Script for screen transition is started when instructed. However, the IO classification (5 columns) = “DO” and the key type (6 columns) of the data item. = “T” and only when it is determined that the data item is the primary key of the database corresponding to the transition destination screen ID (11th column), when the data item is instructed, Java for screen transition (Registered trademark) Script is generated to start Script, while IO classification (5 columns) = “DO” and key type (6 columns) = “T” of the data item If it is determined that the data item is not the primary key of the database corresponding to the transition destination screen ID (11th column), the servlet corresponding to the data item is instructed and the form data is transferred to the servlet. It is good also as a structure which produces | generates a code | cord | chord so that it may transmit.
[0190]
The HTTP session sets a session ID in a cookie and sends it to the client side, and the web browser can use the session object by the session ID in the cookie. However, some web browsers are configured not to accept this cookie, and some web browsers of portable terminals such as mobile phones cannot accept cookies. In order to support such web browsers, rewrite of the web server in the web application execution environment must be set to be effective, and "whether or not the web browser can enjoy cookies by sending a dummy cookie to the web browser etc. If the client does not receive the cookie, a code including a process of transmitting the session ID with the client as a URL parameter to the client may be generated.
[0191]
Thereby, the web application which can respond also to the web browser which cannot receive a cookie can be automatically generated.
[0192]
By designing work with the program code generated by the above processing, generating input / output tables with session variables as data items, and defining the relationship between the input / output tables, the focus of development work is System development using session variables can be easily performed, and development work can be reduced, so the development period can be shortened.
[0193]
Also, by automatically generating session variable objects from business specifications, it is possible to easily perform complex and advanced programming using session variables without requiring special knowledge of Java (registered trademark). Work can be reduced.
[0194]
Furthermore, since a web application can be automatically generated from the input / output table, it is possible to easily develop a web application with excellent maintainability that can flexibly cope with changes in the system environment.
[0195]
In addition, since session variables can be selected and released at arbitrary timings, unnecessary resources on the server side can be reduced, and an excellent web application that can reduce the load on the server can be easily generated.
[0196]
As described above, session variables can be defined in the business specification framework (input / output table) for the server-side program to maintain a session with each client, and session variables are acquired and stored at the user's optimum timing. A web application can be automatically generated.
[0197]
In addition, a mechanism for selecting and releasing a session variable at any timing can be defined within the framework of the business specification, and a web application that automatically releases a session variable at an optimum timing desired by the user can be automatically generated.
[0198]
In addition, since screen transitions can be defined within the framework of business specifications, it is not necessary to grasp all states and screen names in those states, but only the relationship between buttons and transition destination screens between two consecutive screens. This makes it easy to define screen transitions even in a large-scale system, making system development easy and reducing development work without reducing the readability of the entire system. Therefore, the development period can be shortened.
[0199]
Also, by automatically generating a screen transition program from business specifications, it is possible to generate web application programming code without requiring special knowledge of program code such as Java (registered trademark), thereby reducing development work. be able to.
[0200]
By automatically generating web applications from such highly readable definition information, it is possible to easily develop web applications with excellent maintainability that can be flexibly handled even when the system environment changes. .
[0201]
In the present embodiment, the case where a web application using a server-side Java (registered trademark) program is generated has been described. However, the generated program code is not limited to Java (registered trademark), but ASP. It may be a web application such as (Active Server Pages) or PHP (Hypertext Preprocessor).
[0202]
Moreover, although the case where Java (trademark) Script was used was demonstrated, you may use another script language.
[0203]
As described above, session variables can be obtained from the business specifications related to the defined session simply by defining the session variables as part of the business specifications describing the data item database layout and the relationship between the data items. Web applications to be saved / released can be automatically generated.
[0204]
Note that the program generation apparatus of the present invention is applicable not only to the HTTP protocol but also to any protocol as long as it is a sessionless protocol.
[0205]
In addition, the case of generating a web application that uses a session to hold data items that are to be shared between multiple pages of the generated web application has been described. However, the data that is to be shared between multiple pages can be set in a cookie or a client It may be configured to set in the hidden field of the form passed to. However, considering security, it is considered more appropriate to use a session.
[0206]
Further, all the configurations in which the above-described modifications are combined are also within the scope of the present invention.
[0207]
Furthermore, the configuration and contents of the input / output tables in FIGS. 5 and 6 are not limited to this, and it goes without saying that the configurations and contents are configured in accordance with the application and purpose.
[0208]
Although one embodiment has been described above, the present invention can take an embodiment as, for example, a system, apparatus, method, program, or recording medium, and specifically includes a plurality of devices. The present invention may be applied to a system including a single device.
[0209]
Note that the program generation apparatus shown in the present embodiment generates in advance an input / output table (FIGS. 5 and 6) including transition destination screen information associated with buttons and data display items constituting the screen, Based on the input / output table, the code for the web application that performs screen transition is generated. Therefore, it is necessary to know only the relationship between the button and the transition destination screen between two consecutive screens. Screen transition can be easily defined even in a system.
[0210]
On the other hand, in the interactive software constructing / driving apparatus shown in Patent Document 1 shown in the column of the prior art, it is necessary to generate a state transition table in which a state transition definition including a description about a screen name is described. Therefore, it is necessary to grasp all the states in the system. However, in a large-scale system, there are a considerable number of states to be defined, and it is very difficult to grasp all of these states and screen names in those states. Moreover, even if all these states and the screen names in the states can be grasped, managing all of these states and screen names in the state transition definition table as shown in the above-mentioned Patent Document 1 Readability is reduced, maintainability is poor, and errors are likely to occur.
[0211]
In the present invention, the above-mentioned screen transition is also defined in the framework of the input / output table that defines the definition of the data item and the arrangement of the data item in the database. In addition to the state transition definition table described above, the screen item constraint table, the database item correspondence table, and the like need to be created by the user, which is further complicated.
[0212]
Thus, in the definition of screen transition, the present invention and the above-mentioned Patent Document 1 are fundamentally different.
[0213]
Furthermore, in Patent Document 1 shown in the column of the prior art, by preparing a framework in advance, the amount of individual programs to be individually programmed by the user is reduced. However, in the present invention, all codes necessary for the Web application are generated based on the input / output table defining the screen transition. In the present invention, the user uses Java (registered trademark) or the like. There is no need to do any programming that was done. Also in this point, the present invention and the above-mentioned Patent Document 1 are fundamentally different.
[0214]
Furthermore, in the present invention, even when information is transferred to the screen at the transition destination at the time of screen transition, within the framework in the input / output table described above (definition of data items and definition of arrangement of the data items in the database). Is defined in In addition, when transferring information, even the specification of whether to transfer information using a session object or to transfer information without using a session object is within the framework of the input / output table described above. To define.
[0215]
As described above, the present invention solves the various problems of the above-mentioned Patent Document 1, and further allows flexible designation of data transfer between a plurality of pages of a web application within a framework of business specifications. , Non-use, etc.) and an excellent web application program is generated.
[0216]
The points described above are considered matters to be particularly noted when considering the difference between the program generation device shown in the present embodiment and the interactive software construction / drive device described in Patent Document 1.
[0217]
The configuration of a data processing program that can be read by the program generation device according to the present invention will be described below with reference to the memory map shown in FIG.
[0218]
FIG. 21 is a diagram for explaining a memory map of a recording medium (storage medium) for storing various data processing programs that can be read by the program generating apparatus according to the present invention.
[0219]
Although not specifically shown, information for managing a program group stored in the recording medium, for example, version information, creator, etc. is also stored, and information depending on the OS on the program reading side, for example, a program is identified and displayed. Icons may also be stored.
[0220]
Further, data depending on various programs is also managed in the directory. In addition, when a program or data to be installed is compressed, a program to be decompressed may be stored.
[0221]
The functions shown in FIGS. 4, 15, 16, 17, 18, 19, and 20 in this embodiment may be performed by a host computer by a program installed from the outside. In this case, the present invention is applied even when an information group including a program is supplied to the output device from a recording medium such as a CD-ROM, a flash memory, or an FD, or from an external recording medium via a network. Is.
[0222]
As described above, a recording medium recording software program codes for realizing the functions of the above-described embodiments is supplied to a system or apparatus, and a computer (or CPU or MPU) of the system or apparatus stores the recording medium in the recording medium. It goes without saying that the object of the present invention can also be achieved by reading and executing the programmed program code.
[0223]
In this case, the program code itself read from the recording medium realizes the novel function of the present invention, and the recording medium storing the program code constitutes the present invention.
[0224]
As a recording medium for supplying the program code, for example, a flexible disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, DVD-ROM, magnetic tape, nonvolatile memory card, ROM, EEPROM, A silicon disk or the like can be used.
[0225]
Further, by executing the program code read by the computer, not only the functions of the above-described embodiments are realized, but also an OS (operating system) or the like running on the computer based on the instruction of the program code. It goes without saying that a case where the function of the above-described embodiment is realized by performing part or all of the actual processing and the processing is included.
[0226]
Furthermore, after the program code read from the recording medium is written in a memory provided in a function expansion board inserted in the computer or a function expansion unit connected to the computer, the function expansion is performed based on the instruction of the program code. It goes without saying that the case where the CPU or the like provided in the board or the function expansion unit performs part or all of the actual processing and the functions of the above-described embodiments are realized by the processing.
[0227]
Further, the present invention may be applied to a system composed of a plurality of devices or an apparatus composed of a single device. Needless to say, the present invention can be applied to a case where the present invention is achieved by supplying a program to a system or apparatus. In this case, by reading a recording medium storing a program represented by software for achieving the present invention into the system or apparatus, the system or apparatus can enjoy the effects of the present invention. .
[0228]
Furthermore, by downloading and reading out a program represented by software for achieving the present invention from a server, database, etc. on a network using a communication program, the system or apparatus can enjoy the effects of the present invention. It becomes.
[0229]
【The invention's effect】
As described above, according to the present invention, the definition information is defined in advance so that the screen can be defined by a plurality of components and the transition destination screen can be defined when the component of the screen is instructed. Based on the definition information, “first program for generating and displaying a screen composed of the plurality of components”, “second program for controlling screen transition by an event indicating that the components are instructed” It is not necessary to grasp all the states in the system and all the screen names in the system, and only grasps the relationship between the button and the transition destination screen between two consecutive screens. Even in a system, screen transitions can be easily defined, system development can be easily performed without reducing the readability of the entire system, and the development period can be shortened. It can be.
[0230]
In addition, it is possible to define screen transitions within the framework of business specifications that define the definition of data items and the placement of the data items in the database, thus facilitating system development without reducing the readability of the entire system. Development time can be reduced and the development period can be shortened.
[0231]
Furthermore, by automatically generating a screen transition program from business specifications, it is possible to easily generate program code without requiring special knowledge of programming such as Java (registered trademark), thereby reducing development work. be able to.
[0232]
In addition, information to be transferred to a transition destination screen at the time of screen transition can be flexibly specified according to a situation in which the information is passed by a method using a session variable or a method not using a session variable.
[0233]
Therefore, it is possible to realize a desired screen transition, and it is possible to easily develop a web application excellent in maintainability that can flexibly cope with a change in the system environment.
[Brief description of the drawings]
FIG. 1 is a block diagram showing a configuration of a program generation device showing an embodiment of the present invention.
FIG. 2 is a diagram illustrating an example of the overall configuration of a web application system using a servlet, JSP, and Bean generated by a code generation unit illustrated in FIG. 1;
FIG. 3 is a diagram showing a system configuration of a Web server that constitutes an application server of the Web application system generated by the code generation unit shown in FIG. 1;
FIG. 4 is a flowchart showing an example of a first control processing procedure in the program generation apparatus of the present invention.
FIG. 5 is a schematic diagram for explaining a business specification (input / output table) in the program generation apparatus of the present invention.
FIG. 6 is a schematic diagram for explaining business specifications (input / output table) in the program generation apparatus of the present invention.
7 is a diagram showing classification of IO sections in the input / output tables shown in FIGS. 5 and 6. FIG.
8 is a diagram showing classification of key types in the input / output tables shown in FIGS. 5 and 6. FIG.
9 is a diagram showing a classification of processing functions in the input / output table shown in FIGS. 5 and 6. FIG.
FIG. 10 is a schematic diagram showing a concept of program generation processing (configuration of processing) in the program generation device of the present invention.
FIG. 11 is a schematic diagram showing an example of a web application generated in the program generation apparatus of the present invention.
FIG. 12 is a schematic diagram showing an example of a web application generated in the program generation apparatus of the present invention.
FIG. 13 is a schematic diagram showing an example of a web application generated in the program generation apparatus of the present invention.
FIG. 14 is a schematic diagram showing an example of a web application generated in the program generation apparatus of the present invention.
FIG. 15 is a flowchart showing an example of a second control processing procedure according to the present invention.
FIG. 16 is a flowchart showing an example of a third control processing procedure according to the present invention.
FIG. 17 is a flowchart showing an example of a fourth control processing procedure according to the present invention.
FIG. 18 is a flowchart illustrating an example of a fifth control processing procedure according to the present invention.
FIG. 19 is a flowchart illustrating an example of a sixth control processing procedure according to the present invention.
FIG. 20 is a flowchart showing an example of a sixth control processing procedure according to the present invention.
FIG. 21 is a diagram illustrating a memory map of a recording medium (storage medium) that stores various data processing programs that can be read by the program generation device according to the present invention.
[Explanation of symbols]
101 Input device
102 Display device
103 Processing device (CPU, RAM, ROM)
104 External storage device (hard disk)
105 Screen controller
116 Business specification description part
106 Specification Analysis Department
107 Code generator
108 Overall control unit
109 I / O table
112 JSP code
113 Servlet code
114 Bean code

Claims (13)

In a program generation device for generating a web application program,
Storage means for storing a definition of a screen by a plurality of components, and first definition information capable of defining a transition destination screen when the component is instructed to the components of the screen;
Based on the first definition information stored in the storage means, “first program for generating and displaying a screen composed of the plurality of components”, “screen based on an event indicating that the component is instructed” Generating means for generating a “second program for controlling transition”;
A program generation apparatus comprising: The storage means also stores second definition information including definitions of a plurality of data items and definitions of arrangement of the data items in a database.
The program generation apparatus according to claim 1, wherein the constituent elements of the screen include a constituent element corresponding to the data item. 3. The program generation according to claim 2, wherein the generation unit generates a “third program that delivers predetermined information to the transition destination screen according to an event indicating that the component is designated”. apparatus. The storage means also stores third definition information that associates a data item desired to be passed to the transition destination screen when the component is instructed with respect to the component of the screen,
4. The program generation apparatus according to claim 3, wherein the predetermined information is information corresponding to a data item associated with the component by the third definition information. 5. The program generation apparatus according to claim 3, wherein the third program is a program that transfers the predetermined information to the transition destination screen by storing the predetermined information in a session object. 6. 5. The program generation apparatus according to claim 3, wherein the third program is a program that transfers the predetermined information to the transition destination screen without using the predetermined information in a session object. 6. 7. The program according to claim 6, wherein the third program is a program for transferring the predetermined information to the transition destination screen by calling the transition destination screen by specifying the predetermined information as a parameter. Program generator. If the data item associated with the component by the third definition information is the component itself, the third program can store information corresponding to the component without using a session object. 5. The program generation apparatus according to claim 4, wherein the program generation apparatus is generated as a program for transferring information corresponding to the component to the transition destination screen by calling the transition destination screen by specifying a parameter. The program generation apparatus according to claim 6, wherein the third program is a program called from a screen generated and displayed by the first program. The generating means is based on the second definition information stored in the storage means, “a process of storing data corresponding to the data item defined by the second definition information in the database, the data item from the database. The program generation apparatus according to claim 2, wherein a fourth program including a process of acquiring data corresponding to the above is generated. In a program generation method in a program generation device for generating a web application program,
Based on the first definition information that can define the transition destination screen when the component is instructed to the component of the screen and the component of the screen based on the definition of the plurality of components. Generating a “first program for generating and displaying a screen to be displayed” and “a second program for controlling screen transition by an event indicating that the component has been specified” Method. A program for executing the program generation method according to claim 11. A recording medium storing a computer-readable program for executing the program generation method according to claim 11.

Images