JP4231087B2 - Web page screen display system and web page screen display method - Google Patents

Description

  The present invention relates to a technology for improving the development efficiency and maintainability of business application software that processes a company's core business.

  In business applications such as a data entry system and a workflow system in an enterprise business, as shown in FIG. 47, a method of operating data managed by a database server 5402 from a client 5403 via an application server 5401 has been adopted. . In recent years, such business applications have been realized as Web applications.

  Various attempts have been made to develop an application server 5401 that plays a role of controlling a Web browser. Typical examples include an application server 5401 using Servlet and JSP (Java (registered trademark) Server Pages).

  As shown in FIG. 48, the application server 5401 using the Servlet has an HTML (Hyper Text Markup Language) 5501, screen data 5502, logic 5503 (screen input handling, input data check, data Processing, transmission of data to the database server 5402, etc.) are described as one module.

  As shown in FIG. 49, the application server 5401 using JSP has screen data 5602, HTML 5601, and logic stored in an object called Java Bean (Java, Java Beans is a registered trademark of Sun Microsystems, Inc.). It is described as a module composed of 5603, or is implemented by describing a module composed of HTML 5601 ′, screen data 5602 ′ and logic 5603 ′ so as to be stored in the Java Bean object.

  In general, business applications handle a large amount of data. Therefore, the application server 5401 realizes that data (screen data), logic, and screen (HTML, etc.) are described separately for each module, and each module is to be reused. There is a request. However, as shown in FIG. 48 and FIG. 49, it is difficult to separate these modules in the application server 5401 using a conventional technique such as Servlet or JSP.

  Therefore, an object of the present invention is to improve the development efficiency and maintainability of web applications by providing a framework that describes data, logic, and screen modules separately when developing an application server that executes web applications. There is to do.

  In order to solve the above-described problems, in the present invention, the Web application is divided into HTML with a custom tag, data object, and logic, and the HTML with the custom tag and the logic are mapped by a mapping file, and data is exchanged between the two. Use objects.

  According to one aspect of the present invention, input content conversion means for converting the input content of a Web page into a data object, processing logic having a plurality of processing routines, and a combination of the type and command of the data object are set in each processing routine. A first external definition file to be mapped to, a processing routine determining means for determining an appropriate processing routine from a processing routine provided in the processing logic based on the type and command of the data object and the first external definition file; A second external definition file that maps a combination of a processing result of the processing logic and a type of data object to a display component.

  According to another aspect of the present invention, there is provided means for obtaining a data object that has data to be provided to a client and that implements an interface that represents a data structure of the data, and the data object has Means for acquiring a definition sentence that defines a display method on a Web page screen by a description in HTML, and by associating data of the data object with the definition sentence based on the interface implemented in the data object, Means for generating an HTML sentence representing a Web page screen on which the data is displayed.

  According to still another aspect of the present invention, the processing logic in which the content of the processing is defined, the means for generating a character string that is a name of the processing logic prepared in advance, An HTML statement that calls the processing logic using a character string, and calls the processing logic when an event that is an execution condition for the processing logic and that matches the execution condition prepared in advance occurs. Means for generating the HTML statement that causes the client to perform a process of executing the process.

  By adopting such a configuration, the HTML for defining the screen display in the Web application system, the data object, and the logic for defining the contents of the processing become sparse, and the reusability of each module is improved. Development efficiency and maintainability.

  According to the present invention, the HTML that defines the screen display in the Web application system, the data object, and the logic that defines the contents of the processing are sparse, improving the reusability of each module, Maintainability can be improved. In addition, by branching the processing at the server from the larger to the smaller ones in the time scope and proceeding with the processing, thread safety can be realized, and pre-processing and post-processing are added to the processing at each scope to make a pre-processing decision And error processing can be performed flexibly.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 is a diagram showing an outline of the present invention. As shown in the figure, an application server UJI (Uji) that implements the present invention is composed of three modules: HTML 101 that defines screen display, screen data 102, and logic 103. The HTML 101 may be any one that can define the screen display.

  FIG. 2 is a diagram showing the principle configuration of the present invention. The one corresponding to the HTML 101 in FIG. 1 is the input JSP 201 and the display JSP 202, the one corresponding to the screen data 102 in FIG. 1 corresponds to the input Java Bean 203 and the display Java Bean 204, and the logic 103 in FIG. User logic 205. The input JSP 201 has a function of assigning a screen to data, and the display JSP 202 has a function of displaying data on the screen. The UJI engine 206 converts the screen data of the input JSP 201 into a data object such as Java Bean ((1), (5), (6)). That is, the screen data of the input JSP 201 is converted into the input Java Bean 203. The user logic 205 is composed of a plurality of processing routines, and the UJI engine 206 determines an appropriate processing routine based on the type and command of the data object (Java Bean 203 for input) and the external mapping file 207 (( 5), (6), (7)). The user logic 205 processes the input Java Bean 203, which is a data object, using the determined processing routine (2), and outputs it as a display Java Bean 204 ((3)). The Java Bean 204 for display is converted into the screen data of the display JSP 202 by the UJI engine 206 ((4), (5), (6)), and the combination of the processing result and the type of Java Bean for display that is a data object is externally displayed. The mapping file 207 is searched for and a part to be displayed is determined. As described above, the present invention has a configuration in which the data object is interposed between the HTML defining the screen and the logic, so that the screen and the logic can be sparsely connected.

  FIG. 3 is a diagram showing the system configuration of the first embodiment of the present invention. A request 301 from the client is received by the front component 302. The request data included in the request 301 is automatically analyzed by the UJI engine 304, and an input Java Bean 303 as a data object is automatically generated. The UJI engine 304 further refers to the command mapping 305 and determines the processing in the user logic 307 from the type of data object generated from the request data and the command. The user logic 307 reads the generated data object, performs processing according to the determination, and sets the Java Bean 309 for display as the processing result. Here, the UJI engine 304 refers to the page mapping 306, and the display JSP 310, that is, the screen representation, is determined from the display Java Bean 309. The display JSP 310 includes a template 308 that defines the page layout, and display components are arranged according to the template 308.

  FIG. 3 shows the system configuration of the first embodiment of the present invention and outlines the operation thereof. The specific operation of the system of the first embodiment of the present invention will be described with reference to FIG. FIG. 4 shows a state of a Web application called “destination bulletin board” indicating where the user is. A user list display screen 401 for displaying a list of users, a user status editing screen 402 for editing a user status, a profile editing screen 403 for editing a user destination candidate, and a user registration screen 404 for registering a new user are respectively displayed on the client. It is displayed by the browser. When the login button 405 is pressed (clicked) on the user list display screen 401, the screen transitions to the user status editing screen 402. When the user registration button 406 is pressed on the user list display screen 401, the screen shifts to the user registration screen 404. Similarly, when each button of each of the screens 402 to 404 is pressed, the screen changes as indicated by the corresponding arrow shown in FIG. At this time, each button on the screen such as a login 405, a user registration button 406, a change button 407, and a logout button 408 corresponds to a command for the user to request processing from the system.

  For example, when the user “Matsuzuka” wants to add the state “conference room” in addition to the three states “self-seat”, “business trip”, and “annual” that can be displayed as the user state, the user state edit screen 402 Then, the profile editing button 409 is depressed. Then, the screen display transitions to the profile editing screen 403. Here, when the user “Matsuzuka” inputs, for example, “Conference Room” in the “Addition” field and presses the change button 410, a profile editing screen with a new state added is displayed.

Hereinafter, the system configuration of the application shown in FIG. 4 and the outline of the operation will be described with reference to FIGS.
FIG. 5 shows an outline of operations from when a request from a client is received until the processing is completed. A user list display screen 501, a user status editing screen 502, a profile editing screen 503, and a user registration screen 504 displayed on the Web browser correspond to the screens in FIG. When commands such as login, user registration, profile editing, logout, change, user addition, and cancellation are transmitted from each screen to UJI 506 (solid arrow), each screen data is automatically sent to Java Bean 505, which is a data object. (Dotted arrow). Also, the UJI 506 refers to a command mapping 507 (described later), and selects a process to be branched from the processes 508 to 512 based on the combination of the transmitted command and the type of data object. The data object is then passed to the selected process. When a data object is passed, the data object is processed according to the content of the selected process.

  FIG. 6 shows an outline of the operation from the end of the processing of the data object until the response is returned to the client. The processing is completed, and a Java Bean 601 as a processing result is created. In UJI 506, page mapping 602 (described later) is referred to, and pages to be displayed are determined from pages 501 to 504 based on a combination of processing results (success, failure, completion, etc.) and created Java Bean 601. . The created Java Bean 601 is passed to the page to be displayed, and a new page is displayed based on it.

  FIGS. 7A and 7B show part of command mapping, and FIG. 7C shows part of page mapping. The command mapping is composed of a table composed of input data object types, commands, and processes. The page mapping is composed of a table composed of output data object types, processing results, and screens.

  As shown in FIGS. 7A and 7B, processing to branch from the combination of the type of the input data object and the command is determined by command mapping. FIG. 7A shows command mapping when the types of input data objects are the same and the types of commands are different. From FIG. 7A, it can be seen that when the type of the input data object is “user state” and the command is “profile editing”, it is determined to branch the processing to the profile change processing. FIG. 7B shows command mapping when the types of input data objects are different and the commands are the same. As shown in FIG. 4, the “change” command is used on various screens. However, even if the commands are the same, the processes to be branched when the commands are generated are different. When the “change” command is generated on the user status editing screen 402 in FIG. 4, the processing must be branched to the user status change processing. When the “change” command is generated on the profile editing screen 403, the profile change processing is performed. The process must be branched. In the command mapping shown in FIG. 7B, when the type of the input data object is “user state” and a “change” command occurs, the process branches to the user state change process, and the type of the input data object is “edit profile”. It can be specified to branch to the profile editing process when the “change” command occurs. As described above, since the command mapping of the present invention determines the process to be branched from the combination of the type of the input data object and the command, the process to be branched from the type of the input data object is appropriately determined even if the command is the same. You can choose.

  Further, the screen to be displayed is determined from the combination of the type of the output data object and the processing result by the page mapping shown in FIG. In page mapping, as with command mapping, the screen is determined by the combination of the output data object type and the processing result, so even if the processing result is the same, the screen to be displayed from the output data object type is appropriate. It is possible to select.

Command mapping and page mapping are external definition files that can be freely set by the developer. This can increase the flexibility in development.
The operation of the entire system of the first embodiment of the present invention has been described above. Next, a more specific description will be given between each operation.

  FIG. 8 is a diagram showing a program description for converting request data from the client into an input Java bean (between 301 and 303 in FIG. 3). According to this description, when data is input to the data input HTML page 801, the class name ((1) in FIG. 8) corresponding to the specific item (LoginBean) of the data input HTML page 801 is displayed in each input field. A Java Bean 802 for data object input having the name (name) as a property ((2), (2) ′ in FIG. 8) is generated.

  FIG. 9 is a diagram showing a program description of a part for determining a logic process to be executed by using command mapping (between 305 and 307 in FIG. 3). In the command mapping 902, a combination of a class name (LoginBean) corresponding to a specific item on the data input HTML page 901 and a name (name) of a pressed button (submit) is a method of the user logic 903 (handler). It is mapped. Thus, for example, when the login button is pressed down on the data input HTML page 901, the login method of the user logic 903 is executed ((1) in FIG. 9). Similarly, when the password change button is pushed down on the data input HTML page 901, the changePassword method of the user logic 903 is executed ((2) in FIG. 9).

  FIG. 10 is a diagram showing a program description of a portion where the user logic sets a display data object (between 307 and 309 in FIG. 3). The user logic (handler) 1001 performs processing using the database 1002 or the like, and sets a value that needs to be displayed and a processing result as a processing result in a display data object (Java Bean) 1003.

  FIG. 11 is a diagram showing a program description of a part (between 309 and 310 in FIG. 3) for determining a page to be displayed through page mapping. In the page mapping 1102, a combination of processing results set by a class name (UserBean) and user logic (handler) is mapped to a view (JSP in this case) to be displayed. Thereby, when the processing result set in the Java Bean 1101 for display is, for example, succeeded, login-succeeded.jsp 1103 is selected ((1) in FIG. 11), and this is combined with the template 308 in FIG. Is determined. Similarly, when the processing result set in the Java Bean 1101 for display is failed, login-failed.jsp 1104 is selected ((2) in FIG. 11), and this is combined with the template 308 in FIG. 3 to determine the display screen. Is done.

  FIG. 12 is a diagram showing a program description of a part (310 in FIG. 3) that outputs a display screen from JSP. The display JSP 1201 acquires data from the display Java Bean 1202 using a data acquisition tag, and outputs the acquired data as output HTML 1203.

  FIG. 13 is a diagram illustrating a template (between 308 and 310 in FIG. 3) when a plurality of display components are arranged on the display screen. The user logic (handler) 1301 can set a plurality of Java Beans for display at the same time. For example, as shown in FIG. 13, when a Java Bean 1302 for a banner, a Java Bean 1303 for a menu, and a Java Bean 1304 for contents are set by the user logic 1301, JSPs corresponding to the respective Java Beans receive data from the respective Java Beans. Acquire and create each display screen. Since the display position is defined for each JSP in the template 1305, the created display screens are arranged based on the template 1305, and output HTML 1306 is output.

  As described above, in the system according to the first embodiment of the present invention, details of a mechanism for converting an HTTP (Hyper Text Transfer Protocol) request into a data object, processing it, converting the processing result data object into a response, and returning it to the client Said. Next, a system according to a second embodiment of the present invention that processes an XML (extensible Markup Language) file using the same mechanism will be described. 14 and 15 show the system configuration.

  FIG. 14 is a diagram showing processing until the XML file is processed by the logic (handler) when the application server receives the XML file. FIG. 15 shows the processing of the XML file by the logic (handler), and the client It is a figure which shows until a response is returned.

  First, in FIG. 14, when the server receives an XML instance 1401, the XML data binding engine 1404 processes the XML to create a data object (Bean instance 1405). At this time, since the type of the object can be specified from the received XML instance 1401, different types of XML can be received by the same engine. Here, the type of the object is specified using an XML mapping file (not shown, described later). Further, the UJI engine 1403 determines a process (method) to be executed by logic (handler) from the XML tag by referring to the command mapping 1402.

  In FIG. 15, a logic (handler) 1501 creates a data object for transmission (Bean instance 1502) in exactly the same way as for an HTTP request. This is again converted to XML by the XML Data Binding engine 1404, and the transmission XML 1503 is output.

  Note that an XML Data Binding engine 1404 that generates a data object is called from the factory class. Therefore, by preparing a factory class for each type of Binding engine, it is possible to flexibly support a plurality of Binding engines.

  16 and 17 show an outline of the operation of the system shown in FIGS. FIG. 16 corresponds to FIG. 14 and shows the process from when the application server receives the XML file until it is processed by the logic (handler). FIG. 17 corresponds to FIG. It is the figure which showed until it returns a response to a client.

  In FIG. 16, when XML files such as order slip 1601 and shipping slip 1602 are transmitted to the application server (solid arrow), each screen data is automatically converted to Java Bean 1605 which is a data object (dotted line). Arrow). Also, in the UJI 1603, the type of the object of the XML instance is specified using the XML map file 1606, and the data object corresponding to the XML received by the XML Data Binding engine 1604 is created. Also, the UJI 1603 selects a process to be branched from the XML tag and the command mapping 1607 from among processes 1608, 1609, 1610, and the like. Then, the data object is passed to the selected process. When a data object is passed, the data object is processed according to the content of the selected process.

  When the processing is completed, a Java Bean 1701 as a processing result is transferred to the UJI 1603 in FIG. The Java Bean 1701 is converted into an XML instance for transmission 1702 by the XML Data Binding engine 1604.

  As described above, in the system of the second embodiment, the received XML is converted into a data object by the XML Data Binding engine and then passed to the logic (handler). Therefore, when the same processing as the HTTP request is realized, The same logic (handler) method as the system logic (handler) of the embodiment can be used as it is.

The system configuration and system operation of the first and second embodiments of the present invention have been described above in detail. Next, the system operation mechanism common to these embodiments will be described.
Objects constituting the system of the present invention can be classified into four stages of time scopes of system, application, session and request based on the relative positional relationship on the time axis when each is processed. As shown in FIG. 18A, there is one system 1801 in the entire system, and the scope is from the start of the application server to the end of the server. One application 1802 exists for each application in the system, and the scope is from the start to the end of the application. One session 1803 exists for each client, and the scope is from connection to disconnection (or timeout) of the client. One request 1804 exists for each request from a client, and the scope is from processing the request from the client to returning a response. FIG. 18B shows the correlation between the objects. There are a plurality of applications 1802 in the system 1801, and there are sessions 1803 from a plurality of clients connected to each application 1802. A request from the client is processed by a handler 1805 prepared in advance. A request 1804 shown in FIG. 18A corresponds to one thread when each object shown in FIG. 18B is executed.

  In this way, when the objects that make up the system have a gradual temporal scope, when processing a request from a client, the processing proceeds by branching from an object with a larger scope to a smaller object. I can go. That is, as shown in FIG. 19, when a request is transmitted from the client to the front component 1901, one dispatcher 1902 existing in the system branches the processing to the corresponding application 1903. Further, the application 1903 branches the process to the session 1904 corresponding to the client that has transmitted the request, and the session 1904 branches the process to the handler 1905 corresponding to the request.

In the system of the present invention, a request from a client is branched and processed from a larger scope to a smaller scope. Therefore, if the application, session, and handler objects are user-extensible or user-definable, An effect is obtained. (In the system of this embodiment, the application 1903 and the session 1904 can be expanded by the user, and the front component 1901, the display page 1906, the handler 1905, the command map 1909, the page map 1910, the ResponseBean 1908, and the RequestBean 1911 are implemented as user-definable. .)
When an interface called SingleThreadModel 1912 is implemented for a user-expandable or user-definable object (FIG. 19B), the operation of the object is simultaneously limited to a maximum of one thread. If this function is used, the operation of each scope becomes thread-safe, that is, for example, it is possible not to perform a plurality of data processing such as editing the same data at the same time. This is called “single thread operation restriction”. In the above-mentioned “destination bulletin board” application (FIG. 4), user change and profile editing target the same data, so it is necessary to keep the thread safe. In this case, it may be mounted as shown in FIG. That is, the SingleThreadModel interface is implemented in the handler 2004 including the method: user change 2007 and the method: profile edit 2008. Here, since the method: login process 2005, the method: logout process 2006, and the method: user registration do not need to be particularly thread-safe, the handlers 2004 ′ and 2004 ″ do not implement the SingleThreadModel interface. Similarly, in the session and application, if it is desired to make the thread safe, the SingleThreadModel interface may be implemented (2002 ′, 2003 ′). The description method when the SingleThreadModel interface is implemented may be as shown in FIG. 20B, and shows the case where the SingleThreadModel interface is implemented in the session 2003 ′.

  In addition, pre-processing and post-processing interfaces can be implemented in application, session, and handler objects that are user-extensible or user-definable objects. Thereby, a process can be added before and after the execution of the actual process of each object. That is, as shown in the sequence diagram of FIG. 21, the pre-processing ((1) of FIG. 21) and post-processing ((3) of FIG. 21) of the client request production process (handler method) ((2) of FIG. 21). )), And similarly, pre-processing ((4) in FIG. 21), post-processing ((6) in FIG. 21), and application ((8) in FIG. 21) for the session ((5) in FIG. 21). )) For the pre-processing ((7) in FIG. 21) and post-processing ((9) in FIG. 21).

  Using this function, for example, in the pre-processing ((1) in FIG. 21), the processing of the handler method is performed by making a determination by state management in advance before the actual processing of the logic handler method ((2) in FIG. 21). It is possible to provide a check routine for skipping. In the post-processing ((3) in FIG. 21), an error for recovering an error when an error occurs in the pre-processing ((1) in FIG. 21) or the actual processing ((2) in FIG. 21). Handling can be provided. They can also be used to describe common post-processing even when no errors have occurred. Similarly, common pre-processing and post-processing for one client can be described for each session, and common pre-processing and post-processing for a plurality of clients can be described in an application. Since each pre-processing and post-processing can be implemented separately for each scope object, fine control is possible.

  As described above, if the system operation mechanism of the present invention is used, thread safety can be realized, and pre-processing and error processing can be flexibly performed by adding pre-processing and post-processing to processing in each scope. The effect that it comes to be can be acquired.

Next, a mechanism for making a request from the logic handler in the application server of the present invention to the browser will be described.
In the Web application, for example, a request for process A has been sent from the client. Since something happened, the user (client) is inquired whether or not to continue process A, and process A is executed based on the response. There are cases where it is continued or different processing is to be performed. In this way, when an inquiry is made to the user (client) in the middle of processing, and processing is performed based on the result of this inquiry, a general Web application system has a sequence as shown in FIG. Is going. When the request for process A ((1) in FIG. 22 (a)) is transmitted to the server, the server receives it and the handler 1 starts the process. Then, although the process A is not completed, the user is asked whether to continue the process A ((2) in FIG. 22 (а)). A screen such as 2701 is displayed on the client, and the user returns either “Yes” or “No” ((3) in FIG. 22A). Based on this, the handler 2 starts processing.

  As described above, in a general Web application, it may be necessary to interrupt the handler process even if the process A is not completed. In addition, when the user's answer is “Yes”, “No”, etc., a mapping definition for intermediate processing that defines what question is “Yes” or “No” is required.

  Therefore, a mechanism for making a request from the logic handler in the application server as described below to the browser is introduced into the system of the present invention to improve a general Web application system.

  As shown in FIG. 23 (a), in the system of the present invention, a thread buffer object (synchronizer) is provided in the server before calling a handler, and the operation of the handler is monitored. Thus, when the request for process A ((1) in FIG. 23 (а)) is transmitted to the server, the server receives the synchronizer and passes it to the handler 1 ((2) in FIG. 23 (а)). Handler 1 is activated and processing begins. Therefore, when all the processes A are not completed, but when asking the user whether to continue the processes A, the handler 1 calls a method that calls back to the client ((3) in FIG. 23 (а)). The synchronizer returns the handler method as a return value to the browser (client) ((4) in FIG. 23 (а)). A screen like 2201 is displayed on the client, and the user returns either “Yes” or “No” ((5) in FIG. 23A). It is received by the synchronizer and passed to the handler 1 ((6) in FIG. 23 (а)). Thereafter, the handler 1 continues processing. Thus, by providing the thread buffer object, it is not necessary to interrupt the processing of the handler. Also, in the description of the program for realizing the server, in a general Web application, as shown in FIG. 22B, the handler 1 and the handler 2 that receives an event corresponding to the return value of the handler 1 are not described. On the other hand, in the present invention, as shown in FIGS. 23B and 23C, since it can be described in a conditional branch statement in one handler, it is very easy in terms of program description.

  In the embodiment of the present invention described above, HTTP, XML, etc. are targeted as input from the client, but any request from the client may be used, and implementation of these present inventions. In the example, the client request is converted into a data object called Java Bean, but another data object may be used.

  The invention according to the embodiment described above is characterized in that the input from the client is converted into a data object, the data object is processed, and the data object obtained as a processing result is converted into a response to the client and transmitted. In addition, the processing in the server is classified into temporal scopes, and processing is performed by branching from a larger scope to a smaller scope.

Next, further embodiments of the present invention will be described.
In the embodiment described below, when an application server that executes a Web application is developed, an apparent definition (view) of the screen and data embedded in the screen are separately implemented, and the Web application This improves both development efficiency and maintainability.

  In this embodiment, the display unit in the Web application is prepared separately for display data objects and screen appearance (view) definitions. At this time, the display data object has display data itself and is an interface representing a data structure such as a table structure or a tree structure (in this embodiment, this data structure is referred to as a “model”). Create a structure class that implements the display data. In this embodiment, the view definition is described using JSP (Java Server Pages) (the view definition may be simply described in HTML).

  When the display data object and the view definition are executed in the server, an HTML statement that assigns (assigns) display data to a predetermined position on the screen is generated by the execution engine corresponding to the above-described interface. Thereafter, when this HTML sentence is sent to the client, a corresponding screen display is performed by the Web browser provided in the client.

The embodiment described above will be referred to as a “third embodiment” in order to distinguish it from the other embodiments already described.
First, FIG. 24 will be described. This figure shows the system configuration of the third embodiment of the present invention.

  The model object 3001 is an object that holds data to be displayed on a client acquired from a back end such as a database provided on the server side, and holds data sent from the client for passing to the back end. Yes, a model interface 3002 described later is implemented. Note that the model object 3001 can be provided separately as the display model object 3001a and the input model object 3001b, or can be provided as a single model object 3001 sharing both display and input. It is.

  The model interface 3002 is an interface representing the structure of a specific model. For example, an interface corresponding to a target data structure is prepared, such as a table structure for a table structure and a tree model for a tree structure. The

  The framework engine 3003 extracts data held in the display model object 3001a based on the model interface 3002 implemented in the display model object 3001a, and generates an HTML sentence according to the definition of the display JSP 3004. Further, data input to the browser 3005 is analyzed and passed to the input model object 3001b.

The display JSP 3004 defines the appearance of the screen when the display data is expressed in HTML, and is described in a JSP with an original tag introduced.
A browser 3005 is provided in the client and performs screen display according to HTML generated by the framework engine 3003 based on the definition of the display JSP 3004.

  The front component 3006 accepts a request issued from the browser 3005 and passes it to the framework engine 3003. For example, a JSP component or a servlet is used, but an HTTP request is received and a framework engine corresponding to the received content is received. Any device can be used as long as it can call 3003.

Next, the model interface 3002 in FIG. 24 will be described in more detail by taking a table model interface representing a table structure model as an example.
FIG. 25 is a diagram illustrating a declaration example of the table model interface. In this example, a table model interface is defined by a method for obtaining data, a method for obtaining a data class, and a method for assigning data (to the back end).

  These methods will be further described. Methods for obtaining data include a method for obtaining the number of columns in the table (getColumnCount), a method for obtaining the number of rows in the table (getRowCount), and obtaining data for each cell in the table. A method (getValueAt) is used in the definition of FIG.

  As a method for acquiring a data class, a method (getColumnClass and getRowClass) for acquiring each character string for specifying a “class” defined for each column and row is used in the definition of FIG. This “class” is used to define a display method (eg, a format such as a display position and a font size) for data belonging to each column or row, which will be described later. Indicates the “cls” attribute of the renderer tag.

  The data substitution method (setValueAt) is called by the model update process (described later) corresponding to this table model, so that the request from the client can be sent in a data format that depends on the data structure indicated by this table model. The content (cell value and its location on the table) is passed to the backend.

  Next, how an HTML sentence is generated in the third embodiment of the present invention will be described with reference to FIG. In FIG. 24, when the table model framework engine 3003 shown in FIG. 24 is given a display model object 3001a (A) for realizing the table model interface declared in FIG. 25, the framework engine 3003 The generation HTML sentence (C) is generated based on the JSP source (B) corresponding to the display JSP 3004. For convenience of explanation, line numbers are given to the heads of the lines in FIGS. 26 (B) and 26 (C).

The (B) JSP source in FIG. 26 will be described.
In FIG. 26B, the first line specifies the correspondence between the JSP source and the model object (A).

  To further explain the first line, "id = ..." specifies the name when the corresponding model object is referenced in this JSP source, and "cls = ..." corresponds to this JSP source. The class name of the model object to be specified is specified.

  In the first line, “request =...” Designates the lifetime of the model object (A) in the framework engine 3003. This is in consideration of a case where a request corresponding to the model object is returned from the client after the generated HTML sentence (C) is sent to the client and the browser 3005 displays the screen. That is, when true is specified, the model object (A) is stored in the storage area in the framework engine 3003 even after the HTML statement is generated so that the content of such a request can be immediately assigned to the model object. Retained. On the other hand, when “false” is specified, after the HTML sentence is generated, it is not held in the storage area in the framework engine 3003 of the model object (A).

The second and subsequent lines in FIG. 26B are portions in which the appearance of the screen for displaying the table model is defined using tags, and this portion is collectively referred to as “view”.
A view is described using a view tag. The start tag of the view tag for the table model is shown in the second line (<uomf: table>), and the end tag (</ uomf) of the view tag for the table model in the second and 18th lines is shown. : table>) with several table renderers.

  A renderer defines what display method is used to display data at a specified display location. In the description from the third line to the seventeenth line in FIG. 26B, the definition of the renderer for the table model is five in total (a) to (e). Briefly describing the definitions of these table renderers, (a) is for generating table tags (<table> and </ table>), (b) is for defining the table row display method, (C) defines the display method of the normal column in the table, (d) defines the display method of the cell (header cell) in which the heading of each column in the table is shown, (e) is the data input in the table This defines the display method for cells that can be (data updated).

  For each renderer, the start tag (<uomf: tableRenderer>) of the table model renderer tag is described in the first line, and the corresponding end tag (</ uomf: tableRenderer>) is described in the last line. Is done. The data display method is defined by the description of the line between the start tag and the end tag of the renderer tag. Each element constituting the definition of the data display method is called a renderer element.

  In the renderer tag, “type” and “cls” are specified. These are for specifying the place on the screen where the display is performed by the display method defined in the renderer. These designation contents are designated in advance according to the type of model to be handled.

   In “table” in this embodiment, one of table (entire table), row (row), and column (column) is specified in the table model in this embodiment, and display is performed by the display method defined by the renderer. The location of the table is identified.

  In the table model in this embodiment, “cls” can be specified when the above “type” is specified as row or column (there may be no specification). This is linked with both the getRowClass and getColumnClass methods in the above-described table model interface declaration example (FIG. 25). For example, when a column is displayed, the getColumnClass method of the table model interface is called. The view renderer definition is referenced, and the definition of the display method in the renderer corresponding to the return value for the method whose “type” is column and “cls” is called is the display of that column. Is used as a display method for generating HTML sentences. When there is no return value (null) for the called method, the definition of the display method for the renderer for which “cls” is not specified is used.

In the table model in the present embodiment, “cls” is specifically designated header or editable.
The definition of the display method in the renderer is described using a well-known HTML tag, and a special tag called a renderer element tag is introduced here. In FIG. 26B, <uomf: children> and <uomf: value> are renderer element tags. <uomf: children> causes the framework engine to expand the definition of the display method in other renderers at the position of this tag, and <uomf: value> is obtained from the model interface at the position of this tag. Causes the framework engine to perform an operation to display values (display data).

  More detailed operations of these tags are defined in advance depending on the type of model to be handled. In the table model in the present embodiment, <uomf: children> is a renderer (“type”) for a row when this tag appears when the “type” designation in the renderer tag is “table” (entire table). The display method defined by the renderer whose specification is row) is expanded and inserted at this position, and when this tag appears in the renderer whose “type” specification is row (row), the renderer for the column ( It is stipulated that the display method defined by “renderer whose“ type ”is specified as column” is expanded and inserted at this position. <Uomf: value> can only be used in renderers whose “type” is specified as column. The value obtained by the getValueAt method used in the table model interface declaration example (FIG. 25) It is specified to be inserted at a position.

Hereinafter, with reference to FIG. 26, a state in which the generated HTML sentence (C) is generated by the framework engine will be described.
First, the framework engine recognizes that the model object of (A) implements the table model interface, and activates the framework engine for the table model. Then, both the getColumnCount and getRowCount methods of this table model interface are called to recognize the number of columns and rows of the table to be displayed. As a result, it is recognized that a 3 × 3 table is displayed here.

  Next, in the JSP source in (B), the definition of the table renderer in (a) in which “type” is specified as table is first referenced, and the first line of the generated HTML statement in (C) is generated. .

  Here, the renderer element tag <uomf: children> is described in the definition of the table renderer in (a) (the fourth line in (B)), and the “type” in the renderer tag in (a) is set to table. Because it is specified, the definition of the table renderer for the row, that is, the definition of the table renderer of (b) in the JSP source of (B) is expanded, and the second line of the generated HTML statement of (C) is generated. .

  Here, the renderer element tag <uomf: children> is also described in the definition of the table renderer in (b) (the seventh line in (B)), and the “type” in the renderer tag in (b) is set to row. Because it is specified, the definition of the table renderer for the column is expanded. However, since the JSP source of (B) describes three table renderers (renderers whose “type” designation is column) for columns (c), (d), and (e), these Which table renderer definition is to be expanded becomes a problem.

  At this time, in the framework engine, the cell value of each column in the first row of the table to be displayed is acquired from the model object of (A), and the getColumnClass method of the table model interface is called. Through these processes, the cell value obtained here is three character string data of “product name”, “unit price”, and “number”, and the return value for the called method is any of these three values. Was also a header.

  Therefore, the framework engine selects the definition of the table renderer (d) in the JSP source (B) based on the return value for this method, and executes the definition expansion. As a result, the HTML statement indicating the display method of the first row of the table to be displayed (the third, fourth, and fifth rows of the generated HTML statement of (C)) is the definition content of the table renderer of (d) (( B) on the 13th line). Here, since the renderer element tag <uomf: value> is included in the definition of the table renderer in (d), the value of each cell acquired from the model object is inserted into this part.

  Up to this point, the expansion for the renderer element tag <uomf: children> in the definition of the table renderer in (b) (7th line in (B)) is completed, and the next definition following the tag is Based on the description, the sixth line of the generated HTML sentence of (C) is generated, and the generation of the HTML sentence for displaying the first line of the table is completed.

  Next, generation of an HTML statement for displaying the second row of the table is started, and the table renderer for the row, that is, the definition of the (b) table renderer in the JSP source of (B) is expanded again. , (C) The seventh line of the generated HTML statement is generated.

Here, as in the previous case, the table renderer definition in (b) is expanded into the definition of the table renderer for the column of the renderer element tag <uomf: children>.
At this time, the framework engine also obtains the cell value of each column in the second row of the table to be displayed from the model object of (A) and calls the getColumnClass method of the table model interface. The cell values obtained here are three data, “XV-5080”, “198,000”, “” (null), and the return value for the called method is the first two cells. The value for was null data, and the value for the last cell was editable.

  Therefore, the framework engine executes expansion of the definition of the table renderer of (c) in the JSP source of (B) based on the return value of this method for the first two cells. As a result, the HTML statement (the eighth and ninth lines of the generated HTML statement of (C)) indicating the display method of the second row and the first column and the second row and the second column of the table to be displayed is the table renderer of (c). Is generated on the basis of the definition content (line 10 of (B)). Here, since the renderer element tag <uomf: value> is also included in the definition of the table renderer in (c), the value of each cell acquired from the model object is inserted into this part.

  Further, the framework engine performs expansion of the definition of the table renderer of (e) in the JSP source of (B) based on the return value of this method for the last cell described above. As a result, the HTML statement indicating the display method of the second row and the third column of the table to be displayed (the 10th row of the generated HTML statement of (C)) is the definition content of the table renderer of (e) (the (B) 16th line).

  Up to this point, the expansion for the renderer element tag <uomf: children> in the definition of the table renderer in (b) (7th line in (B)) is completed, and the next definition following the tag is The eleventh line of the generated HTML sentence (C) is generated based on the description, and the generation of the HTML sentence for displaying the second line of the table is completed.

  The flow in which the generated HTML statement (C) from the 12th line to the 16th line (HTML sentence for displaying the third line of the table) is generated is because the second line of the table described above is displayed. This is the same as the HTML sentence (from the seventh line to the eleventh line of the generated HTML sentence of (C)).

  Up to this point, the expansion of the renderer element tag <uomf: children> in the definition of the table renderer in (a) (line 4 in (B)) is completed, and the next definition following the tag is Based on the description, the 17th line of the generated HTML sentence of (C) is generated. Thus, the generation of the HTML sentence for displaying the table shown in (C) is completed.

  As described above, the generated HTML sentence is sent to the client. After that, when a request corresponding to this HTML sentence is sent from the client, an input field is displayed on the client by the browser so that the model object can be easily identified. A so-called hidden attribute input tag (<input type = hidden>) is added to the generated HTML statement and sent out. In this input tag, a character string indicating the model type and a unique ID (identifier) for each view used to generate the HTML statement are described, and these data are automatically included in the request. To be included.

  The process described above, in which the table model framework engine 3003 shown in FIG. 24 generates an HTML statement for the browser 3005 to display the table on the client, is shown in FIGS. 27, 28, and 29. Further description will be given along the flowchart. This process is referred to as “display process”.

  The framework engine 3003 first reads a display JSP 3004 and detects a view tag included in the display JSP 3004. Subsequently, each renderer included in the view indicated by the view tag is classified based on “type” and “cls” specified by the renderer tag and registered in a predetermined location of the buffer. Furthermore, after completing this registration, the framework engine 3003 starts processing according to the flowcharts shown in FIGS. 27, 28, and 29 while acquiring data from the model object 3001 specified in the view tag. The processing so far is collectively referred to as “view tag analysis processing”.

FIG. 27 shows an overall flow of control processing at the time of display performed by the framework engine 3003 for the table model.
When the process shown in FIG. 27 is started, first, a view unique ID is generated (S3101). As described above, the unique ID of the view is an ID unique to each view of the display JSP 3004 used for generating the HTML sentence. For example, a common prefix (prefix) such as “uji.model.00001” is used. ) ("Uji.model." Part) and a different serial number ("00001" part) may be generated each time an HTML sentence is generated. This unique ID for each view is displayed for a plurality of model objects, and when a request for each of them is received by the server, each received request is for which model object. And a request including an ID corresponding to the model object is generated at the client.

  Subsequently, from the renderers registered in the buffer of the framework engine 3003 by the above-described processing, those having “type” specified in table are acquired (S3102).

  After that, the renderer display process when the level is set to table and the child level is set to row is executed (S3103). The renderer display process is the process shown in the flowchart of FIG. 28, and details thereof will be described later.

An HTML sentence for displaying the table is generated by the process of S3103 described above. Therefore, the framework engine 3003 generates an input tag with the aforementioned hidden attribute and adds it to the HTML sentence (S3104). The input tag generated here is as follows, for example.
<input type = hidden name = ”uji.model” value = ”uji.model.00001”>
<input type = hidden name = ”uji.model.00001” value = ”table”>
Here, “uji.model.00001” is an example of the unique ID of the previously generated view. By adding these input tags to the HTML sentence, the information corresponding to the request corresponding to the HTML sentence is included, and the correspondence between the request and the model object 3001 becomes clear.

Next, the renderer display process shown in the flowchart of FIG. 28 executed in S3103 of FIG. 27 will be described.
In the following description and drawings, in addition to the renderer element tag notation used so far (for example, <umof: children>), the abbreviation for the uomf: prefix (for example, <children>) is also used. I will do it.

  First, the level at the time this renderer display process is called is checked, and whether or not the elements that define the display method in the renderer whose level is specified as “type” is still left. If it is determined (S3201) and the determination result is Yes, one next element (renderer element) is acquired (S3202), and the process proceeds to S3203. On the other hand, if the determination result in S3201 is No, the renderer display process ends, and the process returns to the original process.

Subsequently, it is determined what kind of element is acquired by the process of S3202 (S3203, S3206, S3208, S3210).
As a result, if the acquired element is a view tag (Yes in S3203), the view tag analysis process described above is performed on this view tag (S3204), and then the process shown in FIG. The process is executed for the view tag (S3205), and after this process is completed, the process returns to S3201.

  The processing in S3204 and S3205 is performed when another view is described during the description of a certain view (the view is nested). For example, the processing is further performed in a certain cell of the table model. This is to cope with the case where there is a model.

  If the element acquired by the processing of S3202 is a renderer element tag of <children> (the determination result of S3206 is Yes), it is checked what the child level was when this renderer display processing was called, and this child A display process for the level is executed (S3207), and after the completion of this process, the process returns to S3201. The display process when the child level is row is shown in the flowchart of FIG. 29A, and the display process when the child level is column is shown in the flowchart of FIG. 29B. These display processes will be described later.

  If the element acquired by the process of S3202 is the renderer element tag of <name> (Yes in S3208), a process for naming elements used in the request is executed (S3209). After this process is completed, the process returns to S3201.

Here, the renderer element tag of <name> will be described. This tag causes the framework engine to generate a name according to a predetermined rule.
In this embodiment, this name is generated according to the rules shown in FIG. Here, the model unique position is a character string for uniquely representing its own position in a certain model. For example, if it represents the second row and the third column in the table model, “2_3” or the like is used. Just generate a string. At this time, if the above-described example of generating the unique ID of the view (“uji.model.00001”) is used as it is, the name generated according to the renderer element tag of <name> at this time is (B )become that way.

By naming according to such a rule, the model object and the position in the model can be specified from this name.
FIG. 31 shows an example of a renderer definition using the <name> renderer element tag. When the description of the definition shown in the figure is described, the value acquired from the model object by <uomf: value /> is inserted into the updatable cell in the table as the value before updating and displayed on the client. Here, a request is transmitted when the value of this cell is updated in the client. In this request, the name generated by <uomf: name /> is used as a reference name for referring to the updated cell value. By doing so, the table model engine can identify the model object and the position in the model from the reference name according to the naming rule described above, so that multiple update data can be included in one request generated by the client. In addition, a plurality of update data for different model objects can be included in one request.

  Further, when the renderer element tag of <uomf: name> is described in the nested view as described above, as shown in the example of FIG. The view unique ID is generated by combining the generated name (for example, the name shown in FIG. 30B) with a prefix number and the like, and the view unique ID is nested in the view unique ID. A combination of model specific positions in the view is generated as the name for the renderer element tag. By this naming rule, it is possible to recognize the existence of the nest and the inheritance relationship of the view from the generated name, and to specify the model related to the nest.

Returning to the description of FIG.
If the element acquired by the determination process of S3202 is a <value> renderer element tag (the determination result of S3210 is Yes), a value corresponding to the current position in this table model is acquired from the model object (S3211). Thereafter, the process returns to S3201.

  On the other hand, if the element acquired by the determination process of S3202 is different from any of the tags described above (the determination results of S3203, S3206, S3208, and S3210 are all No), the acquired element is a generated HTML sentence. (S3212), and the process returns to S3201.

The above processing is the renderer display processing.
Next, the display process for the child level, which is executed in S3207 of the renderer display process described above, will be described. As described above, the display process when the child level is row is shown in the flowchart of FIG. 29A, and the display process when the child level is column is shown in the flowchart of FIG. 29B. Yes.

First, the flowchart of FIG. 29A will be described.
First, the value of the variable row is set to 0, and the processing from S3302 to S3304 is repeated until the value of the variable row exceeds the return value (that is, the number of rows in the table) of the getRowCount () method (S3301).

Subsequently, the row class (getRowClass ()) for the row indicated by the value of the variable row is acquired from the model object 3001 (S3302).
Next, from each renderer registered in the buffer of the framework engine 3003, a renderer in which the acquired row class is specified as “cls” and “type” is specified as row is acquired. (S3303).

  Here, the renderer display process when the level is set to row and the child level is set to column is executed (S3304). The renderer process executed here is the one already described with reference to FIG.

  Thereafter, the value obtained by adding 1 to the value of the variable row is substituted for the variable row, and the process returns to S3301 (S3305). If the value of the variable row reaches the above-described condition, this process ends and returns to the original process.

Next, the flowchart of FIG. 29B will be described. This process is basically the same as the process shown in FIG.
First, the value of the variable column is set to 0, and the processing from S3402 to S3404 is repeated until the value of the variable column exceeds the return value of the getcolumnCount () method (that is, the number of columns in the table) (S3401).

Subsequently, the column class (getColumnClass ()) for the row indicated by the value of the variable row is acquired from the model object 3001 (S3402).
Next, from each renderer registered in the buffer of the framework engine 3003, the renderer whose acquired column class is specified as “cls” and whose “type” is specified as column is acquired. (S3403).

  Here, a renderer display process is executed when the level is column and the child level is none (null) (S3404). The renderer process executed here is also the one already described with reference to FIG.

  Thereafter, the value obtained by adding 1 to the value of the variable column is again assigned to the variable column, and the process returns to S3401 (S3405). If the value of the variable column reaches the above-described condition, this process ends and returns to the original process.

The above processing is display processing.
After this display processing is completed, the framework engine 3003 describes the correspondence between the JSP source of the display JSP 3004 and the model object 3001 (first line in the example of FIG. 26B). Referring to FIG. 32, the storage area management process shown in FIG. 32 is executed. That is, it is determined whether or not request is set to true in this description (S3501). If the determination result is Yes, the contents of the model object 3001 held in the storage unit of the framework engine 3003 are thereafter (S3502), if this determination result is No, the storage area of the model object 3001 in the storage unit of the framework engine 3003 is released (S3503).

  Next, in the system shown in FIG. 24, an operation in which the framework engine 3003 receives a request issued from the browser 3005 and updates the model object 3001 will be described. This operation is referred to as “operation upon request”.

FIG. 33 is a diagram for explaining the outline of the operation at the time of the request in the system shown in FIG.
First, the client receives an HTML sentence including a normal (non-hidden attribute) <input> tag generated by the framework engine 3003, and the browser 3005 equipped on the client displays a table based on the HTML sentence. ing. Here, when data corresponding to the <input> tag is input to the client, the browser 3005 transmits an HTTP request including this data to the server side.

  When receiving the HTTP request, the front component 3006 of the server gives an instruction for starting the framework engine 3003 and passes the request to the framework engine 3003.

  The framework engine 3003 first determines which model the received request is for. This determination uses information on the model type included in the request by the action of the <input> tag of the hidden attribute described above. Here, for example, if it is determined that this request is for a table model, an engine for the table model is selected and started.

  Subsequently, the framework engine 3003 identifies the model object 3001 to which the data included in the request is to be substituted from the unique ID of the view that is included in the request by the action of the <input> tag of the hidden attribute. .

  If the specified model object 3001 is held in the storage area in the framework engine 3003, the data included in the request is substituted for the held model object 3001, and if not, the model object 3001 An object 3001 is newly generated and the data is substituted.

  In order to assign data to the model object 3001, the data to be substituted is converted into an update method corresponding to the model, and an interface method for updating the model object (for example, the table model interface 3002 shown in FIG. 25 is updated). In this case, the model object 3001 may be updated by calling the setValueAt method).

FIG. 34 is a flowchart showing the processing contents of the above-described control processing at the time of request performed by the framework engine 3003.
In FIG. 34, the overall flow of this control process is shown as (A), and the model update process for the table model executed in the middle of this control process is shown as (B).

  The request including the data input in response to the display based on the HTML sentence generated by the display process described above generated by the browser 3005 of the client indicates the reference name of the data based on the naming rule described above. I have already explained that. Therefore, when receiving a request, the framework engine 3003 first extracts all the reference names included in the request. Then, one of the retrieved reference names is assigned to the variable key (S3601).

  Here, it is determined whether or not the value of the variable key represents a model that can be handled by the framework engine 3003 (S3602). If the determination result is Yes, the model object corresponding to the variable key is subsequently determined. It is determined whether 3001 is held in the storage unit of the framework engine 3003 (S3603).

  If the determination result in S3603 is Yes, the model object 3001 held in the storage unit is acquired (S3604). If the determination result in S3603 is No, the model object 3001 is created again (S3605). Then, a model update process is performed on the model object 3001 (S3606).

  After completing the model update process or when the determination result in S3602 is No, another reference name extracted from the request is set in the variable key, and then the above-described processes from S3602 to S3606 are extracted. The process is repeated until it is performed for all the reference names (S3607).

Next, the model update process for the table model shown in FIG. 34B, which is executed in the process of S3606 described above, will be described.
First, the value of the variable key (that is, the reference name of the update data included in the request) is decomposed, and the row (row) and column (column) on the table model from the above-described model specific position constituting the name. Is acquired (S3701).

  Then, the setValueAt () method of the model object 3001 is called, and the position of the acquired row and column of the table model and the value of the update data referred to by this reference name are passed to the method, whereby the model object 3001 is updated (S3702), and then the process returns to FIG.

  When the framework engine 3003 executes the above processing, the model object 3001 is updated based on the request issued from the browser 3005.

FIG. 35 shows an example of a client server system that implements the third embodiment of the present invention described above.
The server 3010 includes a model framework processing unit 3011, a Web server unit 3012, and a back end 3013.

The model framework processing unit 3011 executes a function corresponding to the framework engine 3003 in FIG.
The Web server unit 3012 accepts the HTML sentence generated by the model framework processing unit 3011 to the client (3020a, 3020b, 3020c,...) And the land entry from the client (3020a, 3020b, 3020c,...). The function corresponding to the front component 3006 passed to the model framework processing unit 3011 is executed.

  The back end 3013 operates the data stored in the database 3014 and exchanges data with the model framework processing unit 3011 using the model object 3001.

  Clients (3020a, 3020b, 3020c,...) Are equipped with a browser 3005 and can display a screen based on an HTML sentence sent from the server 3010 and input to an input form included in the display screen. The request is generated and transmitted to the server 3010.

Next, further embodiments of the present invention will be described.
In the embodiment described below, when a web application is developed, a description for calling a definition of a processing script that is logic can be used without being directly described in a module that defines the appearance of a screen. The logic expressed by the definition of the script can be divided into parts, and the separation of the logic and the screen definition is advanced, thereby improving the reusability of the logic and improving the development efficiency of the Web application.

The embodiment described above will be referred to as a “fourth embodiment” in order to distinguish it from the other embodiments already described.
First, FIG. 36 will be described. This figure shows a state in which a script is generated by the fourth embodiment of the present invention, and the script shown in (B) by performing the content conversion processing described later on the description sentence shown in (A). It is shown that an HTML sentence including

  36 (A) and 36 (B) displays a warning screen notifying that a click operation has been performed in response to a click operation performed on a form part for input in the display by the browser. A processing script for performing processing is executed. For convenience of explanation, line numbers are given to the heads of the lines in FIGS.

  According to the conventional Web application development method, in order to cause the browser to perform the above-described processing, an HTML statement as shown in FIG. 36B, that is, a description of a property that is a condition for calling the script portion ( 36 (B) description on the 8th line) and the definition of the operation of the processing script itself (FIG. 36 (B) description on the 1st to 6th lines) are directly described, and the relationship between the two. In order to indicate that, the name of the processing script (action123 () in the example of FIG. 36B) needs to be described in both of them. Therefore, even if one of these needs to be corrected for some reason, it will eventually be necessary to refer to both to see if the correction to one of them affects the other. There was a problem. For this reason, the action definition of the process script and the part that calls the process script are eventually written in the same component, and the reusability of the action definition of the process script is low.

  On the other hand, in the fourth embodiment, a description sentence using various tags as shown in FIG. 6A is created, and the script shown in FIG. The HTML sentence to be included is automatically generated. In FIG. 9A, a name is not specified for the processing script, and a property indicating a condition for starting the processing script (starting with “onclick =” on the eighth line in FIG. The description that specifies the script name) is also not described.

First, the concept necessary for explaining FIG.
FIG. 37 shows the structure of an object used in the fourth embodiment of the present invention.
A component (ScriptComponent) object 4001 is an object that is an event generation source for an object displayed on the screen by the browser. An <input> tag (ValidInputTag object 4011) in the example of FIG. be called. The component tag has an action tag therein, and an event for calling a processing script, which is the content of a property described in the action tag, is specified.

  A container (ScriptContainer) object 4002 is an object for managing the component object 4001 and outputting a processing script of the action object 4003. A <form> tag (ValidFormTag object 4012) in the example of FIG. be called. Note that the container object 4002 inherits the component object 4001 and may itself become an event generation source.

  An action (ScriptAction) object 4003 is an object in which a process that is logic is defined by a script. An <action> tag in the example of FIG. 36A is called an action tag. The action tag includes a custom action tag (CustomActiontag object 4013a) and a my action tag (MyActiontag object 4014b), which will be described in detail later.

  A script call part (ScriptCaller) object 4004 is an object that determines a call method of each process script and an interpretation method of a return value when the process script is individually called according to the occurrence of an event.

  Next, FIG. 38 will be described. This figure explains the outline of the content conversion process. Hereinafter, how the description sentence shown in FIG. 36A is converted will be described with reference to FIG.

  First, the description content of the <form> tag, which is the container object 4102 described in the first line of (A), is stored in the storage unit of the processing apparatus that executes the content conversion apparatus, and is described in the second line. The description content of the <input> tag which is the component object 4101 being stored is similarly stored.

Next, an <action> tag that is an action object 4103 is described in the third line.
In the <action> tag, the event property is always specified. By specifying this property, the script described between this <action> tag and the corresponding end tag is executed for what event generated by which component. In the example of (A), it is shown that the event of “click operation” that occurs in the <input> tag on the second line directly including the <action> tag is targeted.

  Therefore, the <action> tag on the third line is registered as the action object 4103 of this <input> in the <input> tag on the second line, which is the component object 4101 (FIG. 38A).

  Next, a script (“alert (“ clicked! ”) Written between the <action> tag on the third line and the end tag of the <action> tag on the fifth line (that is, only the fourth line). ) ") Is stored as a script to be executed in the <action> tag which is the action object 4103.

  Subsequently, an end tag corresponding to the <input> tag in the second line is described in the sixth line. Here, the generation of the <input> tag (that is, the eighth line in FIG. 36B) is started (FIG. 38B), and the storage content for the <input> tag (that is, FIG. 36A). "Input name =" field1 ""), which is the description content of the first line of, is output.

Subsequently, an output instruction is notified to the <action> tag that is the action object 4103 previously registered in the <input> tag (FIG. 38B).
When this output notification is received by the <action> tag, the specified content of the above-described property for this <action> tag is sent to the component object 4101 and added to the <input> tag being generated (FIG. 38 ( d)). In the example of FIG. 36A, since the event property is designated as “click”, “onclick =” is output to the <input> tag. Thus far, the generation of the outline of the <input> tag by the component object 4101 is completed.

  Furthermore, here, the <action> tag that is the action object 4103 holding the script is registered in the <form> tag that is the container object 4102 (FIG. 38E).

  Finally, the end tag corresponding to the <form> tag in the first line is described in the seventh line of FIG. Here, generation of the <form> tag that is the container object 4102 (FIG. 38 (f)) is started, and output of the first line in FIG. 36 (B) is first performed.

  Subsequently, generation of a script calling part is instructed to the script calling part object 4104 (FIG. 38 (g)). Here, first, the name of the processing script (action123 (target)) is automatically generated and the second and fifth lines in FIG. 36B are output, and then the return value of this processing script is defined. The fourth line is output. Further, the name of the processing script is output to the <input> tag on the eighth line that is the component object 4101 that is the caller of the processing script.

  Finally, the <action> tag, which is the action object 4103 previously registered in the <form> tag, is instructed (FIG. 38 (h)), and the script described above is shown as the third line in FIG. 36 (B). Is output. Thereafter, the <form> tag that is the container object 4102 outputs the 6th, 7th, and 9th lines of FIG. 36B, and the HTML sentence of FIG. 36B is generated. Complete.

39 and 40 are flowcharts showing the content conversion processing described above. Next, this flowchart will be described.
First, in FIG. 39, when processing is started, a description sentence as shown in FIG. 36A is read from the first line.

  It is determined whether or not an action tag is described in this read line (S4201). If it is not an action tag (No in S4201), the contents of the tag described in this line are stored in the storage unit. (S4202), and thereafter, the process returns to S4201, and the determination process for the next line of this line is repeated.

  On the other hand, if an action tag is described in the read line (Yes in S4201), this action tag is registered in the component tag including this action tag (S4203), and then this action A processing script described between the start tag and the end tag of the tag is stored in the storage unit (S4204).

  Next, the line following the line in which the end tag of the action tag is described is read, and it is determined whether or not the end tag of the component tag is described in this line (S4205). As a result, if the end tag of the component tag is not described in this line (the determination result in S4205 is No), the process returns to S4201, and the determination process for this line is repeated.

  On the other hand, if the end tag of the component tag is described in this line (the determination result in S4205 is Yes), generation of the component tag is started and the component tag stored in the storage unit is started. The description content is output (S4206), and the properties of the action tag registered in this component tag are added (S4207).

  Next, the processing proceeds to FIG. 40, where the content of the property of the added action tag is examined, and whether or not the event specified by this property is supported by this component is determined. It is determined (S4208). As a result, if the specified event is not supported by this component (the determination result in S4208 is No), it indicates that there is an error in the original description sentence as the processing result of the content conversion processing. An error notification is output (S4209), and the process ends.

  On the other hand, if the specified event is supported by this component (Yes in S4208, the component tag generation is completed (S4210), and the generated component tag is stored in the storage unit. Stored temporarily. Furthermore, the action tag registered in the component tag is registered in the container tag.

  Next, the line following the line in which the end tag of the component tag is described is read, and it is determined whether or not the end tag of the container tag is described in this line (S4212). As a result, if the end tag of the container tag is not described in this line (No in S4212), the process returns to S4201 (FIG. 39) and the determination process for this line is repeated.

  On the other hand, if the end tag of the container tag is described in this line (the determination result in S4212 is Yes), the output of the container tag is started and the container tag stored in the storage unit is started. The description content is output (S4213).

  Subsequently, the name of the processing script is automatically generated and output by the script calling unit object (S4214), and the component tag is associated with the processing script by describing the name in the temporarily stored component tag. It is done.

  Thereafter, the processing script described in association with the action tag registered in the container tag and previously stored in the storage unit is output (S4215), and finally the output of the <script> tag and the container tag The end tag is output and the generation of the container tag is completed (S4216).

By executing the above processing, an HTML sentence as shown in FIG. 36B is generated from a description sentence as shown in FIG.
This content conversion process may be performed by a processing engine provided alone on the server, but it is combined with the above-described display process by the framework engine described in the third embodiment of the present invention. You may make it process. At this time, the JSP source to be converted in the content conversion process is described as a renderer element in a view in which the appearance of the screen for displaying the model is defined.

Next, application of the fourth embodiment will be described.
In FIG. 36, the script for defining the process is described in the description sentence (A) (line 4), but this process script is not described in the description sentence (A) but is made into a component. First, a method using a processing script will be described.

FIG. 41 is a diagram illustrating an example of script description when a processing script is prepared separately.
In the description shown in FIG. 36 (A), the prefix sf: is attached to all tags, but in the description shown in FIG. 41 (A), the prefix my: is added to the action tag <action>. Is attached. This tag <my: action> is called a “my action tag”, and when this tag is detected in the content conversion process, a process script prepared in advance is output in the process of S4215 (FIG. 40). To do. On the other hand, the action tag with the prefix sf: described so far is particularly called a custom action tag.

  FIG. 42 shows a definition example of a processing script for checking the minimum number of characters in a character string, which is a script corresponding to the my action tag described in FIG. In the definition example shown in FIG. 42, setMinLength () for receiving the MinLength property specified in the My Action tag is defined, and further, in the outputFunctionBody method, the contents of the above-described property are embedded in the output object Writer. It is instructed to output a script.

  When the content conversion process shown in FIGS. 39 and 40 is executed, the process script as shown in FIG. 42 is stored in the storage unit in the process of S4204 of FIG. 39, and the subsequent process of S4215 of FIG. In the process, when the process script is output, an output in which a value is assigned to the variable min is performed. As a result, an HTML sentence shown in FIG. 41B is generated from the description sentence in FIG.

Next, FIG. 43 will be described. This figure is a diagram showing a script description example when a plurality of actions correspond to the same event.
In the description sentence of FIG. 43A, the <input> tag shown in the second line has two action tags in the third and sixth lines. In such a case, in the content conversion process shown in FIGS. 39 and 40, the process from S4201 to S4205 is performed twice by the action of the determination process in S4205 in FIG. > These two action tags are registered in the tag, and a processing script for each action tag is stored.

  After that, when a property is added from the two action tags to the <input> tag in the processing of S4207 in FIG. 39, the contents of the “event” specified in these two action tags are the same in the content conversion processing. It is recognized.

  Based on this recognition result, in the content conversion process, in the process of S4214 of FIG. 40, in addition to the automatic generation of the name of the process script, the second to eighth lines ((a) of FIG. 43B). (Part)), the process call automatic generation for executing the two process scripts in order is performed by the script calling unit object. Correspondence between the same event and a plurality of processing scripts is established by automatic generation of processing scripts by the script calling unit object.

Thereafter, in S4215, the ninth to twelfth lines (part (b)) and the thirteenth to nineteenth lines (part (c)) of FIG. 43B are output.
Next, FIG. 44 will be described. This figure shows an example of script description when an event occurs in a container tag.

  In FIG. 44A, in the description of the action tag on the sixth line, the event property is specified as ““ form.submit ””. This description indicates that it is an action tag for a container tag whose name property is specified as “form”.

  For a container tag for which such a property is specified, in the content conversion process shown in FIGS. 39 and 40, the action tag registration, which is the process of S4203 in FIG. To be done on the tag. Furthermore, when outputting the description contents of the container tag in the processing of S4213 in FIG. 40, the processing performed on the component tag from S4207 to S4210 is performed on the container tag. By doing so, the 14th line (line (a)) of FIG. 44B is generated, and the script can be executed for the event generated in the container tag.

  FIG. 45 shows the configuration of each processing engine and client of the server used in the system that implements each embodiment of the present invention described above. Each of these includes a CPU 5001, a storage unit 5002, an input unit 5003, an output unit 5004, and an I / F unit 5005, and each component is connected to each other via a bus 5006.

The function of each component will be described. A CPU (central processing unit) 5001 controls each component by executing a control program.
The storage unit 5002 includes a ROM (Read Only Memory), a RAM (Random Access Memory), a magnetic storage device, and the like, stores a control program that causes the CPU 5001 to control each component, and works when the CPU 5001 executes the control program. Used as an area or storage area for various data.

The input unit 5003 has a mouse, a keyboard, and the like, and acquires various data corresponding to user operations.
The output unit 5004 has a display or the like, and presents various data to notify the user.

The I / F unit 5005 provides an interface function for connecting to a network, and enables data exchange with other devices via the network.
The configuration shown in FIG. 45 is the same as that of a standard computer. Therefore, it is of course possible to implement the present invention with a standard computer.

  FIG. 46 is a diagram for explaining a method for providing various software programs executed by an information processing apparatus such as a computer according to the present invention. The program and the like are provided by any method among the following three methods (a) to (c), for example.

(a) Provided by being installed in an information processing apparatus 5301 such as a computer. In this case, for example, the program is preinstalled before shipment.
(b) Provided by being stored in a portable recording medium 5302. In this case, a program or the like stored in the portable storage medium 5302 is installed in an external storage device of the information processing device 2301 such as a computer. Examples of the portable storage medium 5302 include a floppy (registered trademark) disk, a CD-ROM, a magneto-optical disk, and a DVD-ROM.

  (c) Provided from the program providing server 5304 on the network 5303. In this case, basically, the information processing apparatus 5301 such as a computer downloads the program stored in the program providing server 5304 to acquire the program. In this case, a transmission signal obtained by modulating a carrier wave with a data signal representing a software program is transmitted from the program providing server 5304 through the network 5303 as a transmission medium, and the information processing apparatus 5301 demodulates the received transmission signal. Then, the software program can be executed by reproducing the software program.

(Supplementary note 1) A Web system that processes a request from a client on a server and returns a response to the client,
The Web system characterized in that the server converts the request into a data object and processes it, and converts the data object as a processing result into a response to the client and returns it.

(Appendix 2) A system for developing and executing a Web application,
An input content conversion means for converting the input content into a data object;
Processing logic with multiple processing routines;
A first external definition file that maps a combination of the type of data object and a command to each processing routine;
Processing routine determination means for determining an appropriate processing routine from processing routines provided in the processing logic based on the type of the data object, the command, and the first external definition file;
A web application development / execution system comprising:

(Appendix 3) A Web application development / execution system according to Appendix 2,
The input content conversion means uses a specific item of the data input page described in HTML as the class name of the data object, and corresponds the name of each input field provided on the data input page to the attribute of the data object A Web application development / execution system that automatically generates a data object program.

(Appendix 4) A system for developing and executing a Web application,
Processing logic with multiple processing routines;
A second external definition file that maps a combination of a processing result of the processing logic and a type of data object to a display component;
A web application development / execution system comprising:

(Appendix 5) A Web application development / execution system according to appendix 4,
Furthermore,
A template file that defines how to arrange multiple display components to be arranged on the page to be displayed is provided.
A Web application development / execution system that outputs a plurality of processing logic processing results based on the template file.

(Appendix 6) A Web application development / execution system according to appendix 2,
Furthermore,
An XML mapping file that maps XML tags and data objects;
It has an XML Data Binding engine that performs mutual conversion between XML tags and data objects.
When a tag described in XML is received as the input content,
The XML Data Binding engine converts the received XML into the data object based on the received XML tag and the XML mapping file,
The processing routine determining means determines an appropriate processing routine from the processing routine in the processing logic based on the data object, the received XML tag, and the first external definition file.
The XML Data Binding engine converts a data object obtained as a processing result of the processing logic into an XML tag and outputs it.
A Web application development / execution system characterized by this.

(Appendix 7) A Web application development / execution system according to Appendix 6,
A Web application development / execution system characterized in that the XML mapping file maps an XML tag that performs the same processing as data based on a certain HTTP to a data object of the same type as the data based on the certain HTTP.

(Appendix 8) A Web application development / execution system according to Appendix 2,
Each processing routine in the processing logic is attribute-defined in the scope in any of the four stages of system, application, session, and request in descending order of temporal scope.
A Web application development / execution system characterized in that when the processing logic performs processing, the processing branches from a larger scope to a smaller scope and proceeds with the processing.

(Supplementary note 9) A Web application development / execution system according to supplementary note 8,
A Web application development / execution system, wherein a preprocessing or postprocessing interface is provided in the processing routine in which any of the scopes has an attribute defined.

(Appendix 10) A Web application development / execution system according to appendix 9,
A Web application development / execution system comprising a check routine for controlling a state in the preprocessing interface.

(Appendix 11) A Web application development / execution system according to appendix 9,
A Web application development / execution system, characterized in that an error handling process for recovering an error for each of the processing routines whose attributes are defined in the scope is provided in the post-processing interface.

(Supplementary note 12) A Web application development / execution system according to supplementary note 8,
A web application development / execution system, wherein a single thread operation restriction is provided in any of the processing routines in which the scope is defined as an attribute.

(Additional remark 13) The recording medium which recorded the program read by it when used by a computer,
Converting the input into a data object;
Determining an appropriate processing routine from processing routines in processing logic based on the data object type, command, and an external definition file that maps the combination of data object type and command to each processing routine; ,
A computer-readable recording medium on which a program for causing the computer to execute is recorded.

(Supplementary Note 14) A Web system that processes a request from a client on a server and returns a response to the client,
Each object processed in response to the request in the server has an attribute definition for a temporal scope based on the relative positional relationship on the time axis when each is processed,
The Web system, wherein the server branches from an object for which a larger temporal scope is defined to an object for which a smaller temporal scope is defined, and advances the processing of the object according to the request.

(Supplementary note 15) The Web system according to supplementary note 14,
A Web system characterized in that each object has an attribute definition of any one of a system, an application, a session, and a request in descending order of temporal scope.

(Supplementary Note 16) A Web system that processes a request from a client on a server and returns a response to the client,
A Web system characterized in that when a processing routine is called at a server, the processing operation by the processing routine is monitored, and an object for continuing the progress of the processing is executed by the server.

(Supplementary Note 17) A Web application generation device that is provided on a server side that exchanges various data with a client and generates an HTML sentence that represents a Web page screen on which data to be provided to the client is displayed.
A data object storage means for storing a data object that has data to be provided to the client and that implements an interface representing a data structure of the data;
Definition statement storage means for storing a definition statement that defines a display method of the data included in the data object on the Web page screen by description in HTML;
HTML sentence generation means for generating an HTML sentence representing a Web page screen on which the data is displayed by associating data of the data object with the definition sentence based on the interface implemented in the data object When,
A Web application generation device characterized by comprising:

(Supplementary note 18) The Web application generation device according to supplementary note 17,
The definition statement is defined by Java Server Pages (JSP),
The HTML sentence generation means generates the HTML sentence from a definition sentence defined by JSP.
A Web application generation apparatus characterized by that.

(Supplementary note 19) The Web application generation device according to supplementary note 17,
Further comprising a data class acquisition means for acquiring a data class which is an attribute defined corresponding to the data structure;
The HTML statement generation means selects the definition statement to be associated with data included in the data object based on the data class.
A Web application generation apparatus characterized by that.

(Supplementary note 20) The Web application generation device according to supplementary note 17,
A request acquisition means for acquiring the request sent from the client, the request including input data to the input form shown on the Web page screen expressed by the HTML sentence generated by the HTML sentence generation means; ,
A character string included in the HTML sentence generated by the HTML sentence generator included in the request together with the data, the character string specifying an interface based on which the HTML sentence is generated; Based on the character string composed of a character string indicating a specific position in the data structure represented by the interface, data at a specific position in the data structure represented by the interface specified by the character string is included in the request. Data updating means for updating to the included data;
A Web application generation apparatus characterized by further comprising:

(Supplementary note 21) The Web application generation device according to supplementary note 20,
The Web application generation apparatus characterized in that a character string included in the request together with the data indicates a parameter name referring to data input to the input form.

(Supplementary note 22) The Web application generation device according to supplementary note 20,
The Web application generation apparatus, wherein the request includes the data and the character string regarding an HTML sentence generated based on a different interface.

(Supplementary note 23) The Web application generation device according to supplementary note 20,
The data update unit updates the data included in the data object stored in the data object storage unit to the data included in the request.

(Supplementary note 24) The Web application generation device according to supplementary note 20,
The character string included in the request together with the data is composed of a character string that specifies an interface on which the HTML sentence is generated and a character string that indicates a specific position in the data structure represented by the interface. The character string is formed by combining a character string that further includes a character string that specifies an interface representing a data structure of the data group at the position and a character string that indicates a specific position in the data structure represented by the interface,
The data update means updates data at a specific position in a data structure further included in a specific position in the data structure specified by the character string to data included in the request.
A Web application generation apparatus characterized by that.

(Supplementary Note 25) A method for generating an HTML sentence representing a Web page screen on which data to be provided to a client is displayed on a server side that exchanges various data with the client,
Obtaining a data object that has data to be provided to the client and that implements an interface representing the data structure of the data;
Obtaining a definition statement that defines a display method of the data of the data object on the Web page screen by a description in HTML;
Generating an HTML sentence representing a Web page screen on which the data is displayed by associating the data object and the definition sentence based on the interface implemented in the data object;
A Web application generation method characterized by comprising:

(Supplementary Note 26) Control that generates an HTML sentence representing a Web page screen on which data to be provided to the client is displayed by causing the computer to execute on the server side that exchanges various data with the client. A recording medium recording a control program to be executed by a computer,
Control to obtain a data object that has data to be provided to the client and that implements an interface that represents the data structure of the data;
Control for obtaining a definition statement that defines a display method of the data included in the data object on the Web page screen by description in HTML;
Control for generating an HTML sentence representing a Web page screen on which the data is displayed by associating the data object with the definition sentence based on the interface implemented in the data object;
A storage medium storing a control program for causing a computer to execute the above.

(Supplementary Note 27) Control that generates an HTML sentence that represents a Web page screen on which data to be provided to the client is displayed is executed by a computer on the server side that transmits and receives various data to and from the client. A computer data signal embodied in a carrier wave including a control program to be executed by a computer, the control program comprising:
Control to obtain a data object that has data to be provided to the client and that implements an interface that represents the data structure of the data;
Control for obtaining a definition statement that defines a display method of the data included in the data object on the Web page screen by description in HTML;
Control for generating an HTML sentence representing a Web page screen on which the data is displayed by associating the data object with the definition sentence based on the interface implemented in the data object;
To the computer.

(Supplementary Note 28) A Web application generation apparatus that is provided on a server side that exchanges various data with a client and generates an HTML sentence that represents a Web page screen on which data to be provided to the client is displayed.
Processing logic storage means for storing processing logic in which the contents of processing are defined;
Execution condition storage means for storing execution conditions of the processing logic;
Processing logic name generation means for generating a character string to be the name of the processing logic;
An HTML statement that calls the processing logic using the character string, and causes the client to perform a process of calling and executing the processing logic when an event that matches the execution condition occurs in the client. HTML sentence generation means for generating an HTML sentence;
A Web application generation device characterized by comprising:

(Supplementary note 29) The Web application generation device according to supplementary note 28,
The web application generation apparatus, wherein the processing logic is defined by a script.

(Supplementary note 30) The Web application generation device according to supplementary note 28,
The processing logic storage unit and the execution condition storage unit store the processing logic and the execution condition in the same component in which both the processing logic and the execution condition are defined, respectively. Generator.

(Supplementary note 31) The Web application generation device according to supplementary note 28, wherein
A plurality of the processing logic is stored in the processing logic storage means,
When any one of the execution conditions of each of the plurality of processing logics is the same, the processing logic generation unit further generates processing logic that sequentially executes the processing logics having the same execution condition. ,
The character string generation means generates a character string having a different name for each of the plurality of processing logics and the processing logic generated by the processing logic generation means,
The HTML statement generation means is an HTML statement that calls the processing logic generated by the processing logic generation means using the character string, and an event that matches the same execution condition occurs in the client Generating the HTML statement that causes the client to perform the process of calling and executing the processing logic.
A Web application generation apparatus characterized by that.

(Supplementary note 32) The Web application generation device according to supplementary note 28,
A Web application generation apparatus, further comprising a confirmation unit configured to confirm validity of a correspondence relationship between the processing logic and an execution condition of the processing logic.

(Supplementary Note 33) A Web application generation method for generating an HTML sentence representing a Web page screen on which data provided to a client is displayed on a server side that exchanges various data with the client,
A processing logic in which the content of processing is defined, and a character string that is a name of the processing logic prepared in advance is generated,
An HTML statement that calls the processing logic using the character string, and the processing logic when an event that is an execution condition for the processing logic and that matches the prepared execution condition occurs in the client Generating the HTML statement that causes the client to perform the process of calling and executing
A Web application generation method characterized by the above.

(Supplementary Note 34) On the server side that transmits and receives various data to and from the client, the computer executes the control to generate an HTML sentence that represents the Web page screen on which the data to be provided to the client is displayed. A recording medium recording a control program to be executed by a computer,
A process logic in which the content of the process is defined, and a control for generating a character string that is a name of the process logic prepared in advance;
An HTML statement that calls the processing logic using the character string, and the processing logic when an event that is an execution condition for the processing logic and that matches the prepared execution condition occurs in the client Control for generating the HTML statement that causes the client to perform a process of calling and executing
A storage medium storing a control program for causing a computer to execute the above.

(Additional remark 35) Control which produces | generates the HTML sentence which represents the web page screen on which the data provided to this client is displayed by making a computer perform on the server side which transmits / receives various data between clients is this said. A computer data signal embodied in a carrier wave including a control program to be executed by a computer, the control program comprising:
A process logic in which the content of the process is defined, and a control for generating a character string that is a name of the process logic prepared in advance;
An HTML statement that calls the processing logic using the character string, and the processing logic when an event that is an execution condition for the processing logic and that matches the prepared execution condition occurs in the client Control for generating the HTML statement that causes the client to perform a process of calling and executing
To the computer.

(Supplementary note 36)
Converting the input into a data object;
Determining an appropriate processing routine from processing routines in processing logic based on the data object type, command, and an external definition file that maps the combination of data object type and command to each processing routine; ,
A program for running

(Supplementary Note 37) A control for generating an HTML sentence representing a Web page screen on which data to be provided to the client is displayed by causing the computer to execute on the server side that exchanges various data with the client. A control program to be executed by a computer,
Control to obtain a data object that has data to be provided to the client and that implements an interface that represents the data structure of the data;
Control for obtaining a definition statement that defines a display method of the data included in the data object on the Web page screen by description in HTML;
Control for generating an HTML sentence representing a Web page screen on which the data is displayed by associating the data object with the definition sentence based on the interface implemented in the data object;
A control program that causes a computer to perform

(Supplementary Note 38) On the server side that transmits and receives various data to and from the client, the computer executes the control to generate an HTML sentence that represents the Web page screen on which the data to be provided to the client is displayed. A control program to be executed by a computer,
A process logic in which the content of the process is defined, and a control for generating a character string that is a name of the process logic prepared in advance;
An HTML statement that calls the processing logic using the character string, and the processing logic when an event that is an execution condition for the processing logic and that matches the prepared execution condition occurs in the client Control for generating the HTML statement that causes the client to perform a process of calling and executing
A control program that causes a computer to perform

It is a figure which shows the outline of this invention. It is a figure which shows the principle structure of this invention. It is a figure which shows the system configuration | structure of the 1st Example of this invention. It is a figure which shows the mode of a specific operation | movement of the system of the 1st Example of this invention. FIG. 5 is a diagram for explaining an outline of a system configuration of an application shown in FIG. 4 and its operation (until a request from a client is received and processed). FIG. 5 is a diagram for explaining an overview of the system configuration of the application shown in FIG. 4 and its operation (until a response is returned to the client). (A), (b) is a part of command mapping, and (c) is a part of page mapping. It is a figure which shows the program description which converts the request data from a client into Java Bean for input. It is a figure which shows the program description which determines the process of the logic which should be performed via command mapping. It is a figure which shows the program description which a user logic sets the data object for a display. It is a figure which shows the program description which determines the page which should be displayed via page mapping. It is a figure which shows the program description which outputs a display screen from JSP. It is a figure explaining the template in the case of arrange | positioning several display components on a display screen. It is FIG. (1) which shows the system configuration | structure of the 2nd Example of this invention. It is FIG. (2) which shows the system configuration | structure of the 2nd Example of this invention. It is a figure which shows the operation | movement (until an XML file is received and processed) of the system which processes an XML file. It is a figure which shows the outline | summary of operation | movement (until a process result is returned when an XML file is received) of the system which processes an XML file. (A) is a figure explaining the scope of the object which comprises the system of this invention, (b) is a figure which shows the correlation between objects. (A) is a figure explaining the request processing from a client, (b) is a figure explaining mounting of SingleThreadModel. (A) is a figure which shows the specific implementation of SingleThreadModel, (b) is a figure which shows the example of a program description of the implementation of SingleThreadModel. It is a sequence diagram in the case of processing a client request. (A) is a figure explaining the mechanism which calls back to a browser from a logic handler in a general application server, (b) is a figure which shows the example of a program description. (A) is a diagram for explaining a mechanism for making a request from a logic handler to a browser in the application server of the present invention, and (b) and (c) are diagrams showing examples of the program description. It is a figure which shows the system configuration | structure of the 3rd Example of this invention. It is a figure which shows the example of declaration of a table model interface. It is a figure explaining a mode that an HTML sentence is generated in the 3rd example of the present invention. It is a flowchart (the 1) which shows the processing content of the control processing at the time of a display. It is a flowchart (the 2) which shows the processing content of the control processing at the time of a display. It is a flowchart (the 3) which shows the processing content of the control processing at the time of a display. It is a figure explaining the renderer element tag of <name>. It is a figure which shows the example of a renderer definition using the renderer element tag of <name>. It is a flowchart which shows the processing content of a storage area management process. It is a figure explaining the outline | summary of the operation | movement at the time of the request in the system shown in FIG. It is a flowchart which shows the processing content of the control processing at the time of a request. It is a figure which shows the example of the client server system which implements the 3rd Example of this invention. It is a figure which shows a mode that an HTML sentence is produced | generated by the 4th Example of this invention. It is a figure which shows the structure of the object used in the 4th Example of this invention. It is a figure explaining the outline | summary of a content conversion process. It is a flowchart (the 1) which shows the processing content of a content conversion process. It is a flowchart (the 2) which shows the processing content of a content conversion process. It is a figure which shows the example of a script description in the case of preparing a processing script separately. It is a figure which shows the example of a definition of the process script which checks the minimum number of characters of a character string. It is a figure which shows the example of a script description in case a some action respond | corresponds with respect to the same event. It is a figure which shows the example of a script description when an event generate | occur | produces in a container tag. It is a figure which shows the structure of each processing engine and client of a server used for the system which implements each Example of this invention. It is a figure explaining the provision method of the software program etc. concerning this invention. It is a figure which shows embodiment of a business application. It is a figure which shows the system configuration | structure of the application server using Servlet. It is a figure which shows the system configuration | structure of the application server using JSP.

Explanation of symbols

101 HTML
102 Screen data 103 Logic 201 JSP for input
202 JSP for display
203 Java Bean for input
204 Java Bean for display
205 User Logic 206 UJI Engine 207 Mapping File 301 HTTP Request 302 Front Component 303 Java Bean for Input
304 UJI Engine 305 Command Mapping 306 Page Mapping 307 User Logic 308 Template 309 Java Bean for Display
310 JSP for display
401 User List Display Screen 402 User Status Edit Screen 403 Profile Edit Screen 404 User Registration Screen 405 Login Button 406 User Registration Button 407 Change Button 408 Logout Button 409 Profile Edit Button 410 Change Button 411 Return Button 412 Change Button 413 Return Button 501 User List Display screen 502 User status editing screen 503 Profile editing screen 504 User registration screen 505 Java Bean (automatic generation)
506 UJI
507 Command mapping 508 Login processing 509 Logout processing 510 User status change processing 511 Profile change processing 512 User registration processing 601 Java Bean (created in the processing)
602 Page mapping 801 HTML page for data input 802 Java bean for input
901 HTML page for data input 902 Command mapping 903 User logic (handler)
1001 User logic (handler)
1002 Database 1003 Java Bean for display
1101 Java Bean for display
1102 page mapping 1103 login-succeded.jsp
1104 login-failed.jsp
1201 JSP for display
1202 Java Bean for display
1203 output HTML
1301 User logic (handler)
1302 Java Bean for display (for banner)
1303 Java Bean for display (for menu)
1304 Java Bean for display (for content)
1305 Template 1306 HTML for output
1401 XML instance 1402 Command mapping 1403 UJI engine 1404 XML Data Binding engine 1405 Bean instance 1501 Logic (handler)
1502 Data object for transmission 1503 Transmission XML instance 1601 Order slip XML
1602 Shipping document XML
1603 UJI
1604 XML Data Binding Engine 1605 Java Bean
1606 XML map file 1607 Command mapping 1608 Order processing 1609 Shipment processing 1610 Processing 1701 Java Bean
1702 Send XML
1801 System 1802 Application 1803 Session 1804 Request 1805 Handler 1901 Front component 1902 Dispatcher 1903 Application 1904 Session 1905 Handler 1906 Display page 1907 Display Context
1908 ResponseBean
1909 Command map 1910 Page map 1911 RequestBean
1912 SingleThreadModel
2001 system 2002 application 2003 session 2004 handler 2005 login processing method 2006 logout processing method 2007 user change method 2008 profile editing method 2009 user registration method 3001 model object 3001a display model object 3001b input model object 3002 model interface 3003 framework engine 3004 display JSP
3005 Browser 3006 Front component 3010 Server 3011 Model framework processing unit 3012 Web server unit 3013 Backend 3014 Database 3020a, 3020b, 3020c Client 4001, 4101 Component object 4002, 4102 Container object 4003, 4103 Action object 4004, 4104 Script calling unit 4011 ValidInputTag object 4012 ValidFormTag object 4013a CustomActionTag object 4013b MyActionTag object 5001 CPU
5002 Storage unit 5003 Input unit 5004 Output unit 5005 I / F unit 5006 Bus 5301 Information processing apparatus (computer)
5302 Portable recording medium 5303 Network 5304 Program providing server 5401 Application server 5402 Database server 5403 Client 5501 HTML
5502 Screen data 5503 Logic 5601 HTML
5602 Screen data 5603 Data

Claims (5)

A client device connected via a network and a server device that exchanges various data with the client device. A Web page screen on which data provided by the server device is displayed is displayed on the Web page screen. A web page screen display system for displaying on a display of a client device,
The server device
A model object which is a JavaBeans object having data to be provided to the client device, and in which a method for obtaining data is defined according to the table structure of the data is implemented. A model object storage means for storing the model object of a certain class ;
About data possessed by the model object obtained as a return value of a method defined in the model interface implemented in the model object class stored in the model object storage means, and data possessed by the model object A data processing means for generating an HTML statement representing the Web page screen on which the data is displayed by associating a display method on the Web page screen with a definition statement defining the table structure by a description in HTML ,
Have
The definition statement is a description for displaying, in the form of a table, data held by the model object obtained as a return value of a method defined by the model interface implemented by the model object class. Including at least the description of HTML for displaying each of the data in a predetermined cell in the table;
The data processing means includes
Each as the return value, data and the table showing the number of rows and columns in the table of the method to get the value of the method, the method for acquiring the number of columns, the cells to get the number of rows that are defined in the model interface And the data that is the cell value of each column for each row of
In the HTML description for displaying each of the data of the model object included in the definition statement at a specified display location in the table, each of the acquired data is the data of the data. By combining according to the order in the model object, an HTML sentence representing the Web page screen is generated,
The client device has display control means for controlling the display based on an HTML sentence generated by the data processing means and displaying a Web page screen expressed in the HTML sentence.
A Web page screen display system characterized by the above. The web page screen display system according to claim 1,
The data processing means acquires a data class that is an attribute defined corresponding to the table structure, and associates the data of the model object with the definition statement based on the data class.
A Web page screen display system characterized by the above. The web page screen display system according to claim 1,
The server device is a request sent from the client device after sending the HTML statement generated by the data processing means to the client device, and is shown on the Web page screen expressed by the HTML statement. A request acquisition means for acquiring a request including input data to the input form,
The data processing means includes a character string included in the HTML sentence generated by the data processing means, which is included in the request together with the input data, and is a model interface based on which the HTML sentence is generated. An interface specified by the character string based on the character string consisting of a character string specifying a specific position in the table structure obtained as a return value of a method defined in the model interface Update the data at a specific position in the table structure obtained as the return value of the method defined in 1. to the data included in the request.
A Web page screen display system characterized by the above. A web page screen display system according to claim 3,
The character string included in the request together with the input data is a table that is obtained as a character string that identifies a model interface used as a basis for generating the HTML statement and a return value of a method defined in the model interface. A character string that specifies a model interface in which a method for obtaining data is further defined according to a table structure of a data group at the position in a character string including a character string indicating a specific position in the structure , and the model Combining a character string consisting of a character string indicating a specific position in the table structure obtained as a return value of the method defined in the interface,
The data processing means updates data at a specific position in the table structure further provided at a specific position in the table structure specified by the character string to data included in the request.
A Web page screen display system characterized by the above. A client device connected via a network and a server device that exchanges various data with the client device. A Web page screen on which data provided by the server device is displayed is displayed on the Web page screen. A web page screen display method performed by a web page screen display system for displaying on a display of a client device,
A model object that is a JavaBeans object that is stored in a model object storage unit included in the server device and has data to be provided to the client device, and data corresponding to the table structure of the data The model object of the class that implements the model interface in which the method for obtaining the method is defined , the data obtained as the return value of the method, and the Web page screen for the data of the model object by associating the definition statements defining the said table structure display method by a description in HTML in the HTML statements that represent Web page screen to which the data is displayed the data processing means with the said server device generates ,
The definition statement is a description for displaying, in the form of a table, data held by the model object obtained as a return value of a method defined by the model interface implemented by the model object class. Including at least the description of HTML for displaying each of the data at a specified display location in the table;
The data processing means includes
Each as the return value, data and the table showing the number of rows and columns in the table of the method to get the value of the method, the method for acquiring the number of columns, the cells to get the number of rows that are defined in the model interface And the data that is the cell value of each column for each row of
In the HTML description for displaying each of the data of the model object included in the definition statement at a specified display location in the table, each of the acquired data is the data of the data. By combining according to the order in the model object, an HTML sentence representing the Web page screen is generated,
Display control means of the client device controls the display based on the HTML sentence generated by the data processing means to display a Web page screen expressed in the HTML sentence;
A Web page screen display method characterized by the above.

Images