JP4136271B2 - Application server system - Google Patents

Application server system Download PDF

Info

Publication number
JP4136271B2
JP4136271B2 JP2000143123A JP2000143123A JP4136271B2 JP 4136271 B2 JP4136271 B2 JP 4136271B2 JP 2000143123 A JP2000143123 A JP 2000143123A JP 2000143123 A JP2000143123 A JP 2000143123A JP 4136271 B2 JP4136271 B2 JP 4136271B2
Authority
JP
Japan
Prior art keywords
item
data
program
object
screen
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
JP2000143123A
Other languages
Japanese (ja)
Other versions
JP2001325098A (en
Inventor
伸裕 中村
Original Assignee
住友電気工業株式会社
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 住友電気工業株式会社 filed Critical 住友電気工業株式会社
Priority to JP2000143123A priority Critical patent/JP4136271B2/en
Publication of JP2001325098A publication Critical patent/JP2001325098A/en
Application granted granted Critical
Publication of JP4136271B2 publication Critical patent/JP4136271B2/en
Application status is Active legal-status Critical
Anticipated expiration legal-status Critical

Links

Images

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to improvement of an application program development and execution method, and more particularly to improvement of a program development environment and an execution environment for greatly expanding a portion that can be shared between programs in so-called object-oriented programming.
[0002]
[Prior art]
Conventionally, in system development using a computer, reduction of development cost, shortening of delivery time, and improvement of quality have been important goals. For this reason, for example, conversion from a procedure-centric design method to a data-centered design method, introduction of a RAD (rapid application development) development method, program componentization, and the like have been attempted, and certain effects have been achieved.
[0003]
For example, the introduction of data-centric design and development techniques has led to significant productivity improvements. Further, in the RAD development method, the development cycle can be shortened such that prototyping is performed in accordance with the user's request, and the user's request is further confirmed based on the result to correct the prototyping. As a result, in the system that introduced the RAD development method, the external design and the detailed design period were shortened and the cost was reduced. As a result, the proportion of the program creation phase in the overall system development has become relatively large.
[0004]
Recently, intranets are increasingly used as the development platform for enterprise core systems. In such a core system, it is efficient for a networked company to adopt an application server for system construction. Typically, in the application server system development, a tag language that extends HTML (HyperText Markup Language) is used. Such a tag language is easy to learn and is highly regarded as having high productivity as an intranet development tool.
[0005]
However, as the environment surrounding companies becomes more severe, the requirements for system development have become stricter. Specifically, since the business cycle of companies has been shortened, further shortening of the delivery time is required, and companies that can provide products at lower costs are becoming more advantageous.
[0006]
Therefore, as described above, since the ratio of the program creation face in system development is relatively large, it is important to further improve the productivity of this part. For this purpose, the most efficient approach is to promote program componentization.
[0007]
Program componentization reduces the man-hours required for system development, and as a result, contributes to strengthening the competitiveness of system development both in terms of shortening the time required for system development and reducing the cost required for it. In addition, it is possible to contribute to improving the quality of the system by converting only sufficiently reliable programs into parts. Therefore, it is important how efficiently the program can be divided into parts, and how to efficiently combine the prepared parts to construct an application program.
[0008]
However, the tag language that has been used for the development of intranet systems in the past has a weak componentization function. Therefore, as long as the conventional tag language is used as it is, it is clear that improvement in productivity cannot be expected so much.
[0009]
FIG. 32 shows a general system configuration diagram of an intranet using a database (DB). Referring to FIG. 32, a general intranet 600 includes an application server 612, a DB server 614, and a plurality of client PCs 616 that can communicate with each other via a network 610 using a protocol called HTTP. Note that “HTTP” is an abbreviation for Hyper Text Transfer Protocol.
[0010]
A general browser 630 operates on the client PC 616.
In the DB server 614, an RDBMS 622 is operating.
[0011]
A WWW server 618 is running on the application server 612. “WWW” is an abbreviation for World Wide Web. The entity of the WWW server 618 is a Java servlet engine 620. The Java servlet engine 620 provides the browser 630 with information (HTML source) for forming a screen for accessing the RDBMS 622 in response to a request given from the browser 630 of the client PC 616 via the network 610. The browser 630 displays this screen and returns information input by the user to the Java servlet engine 620. The Java servlet engine 620 accesses the RDBMS 622 according to the given information, and returns an HTML source for displaying the result to the browser 630. The browser 630 responds to the user's request by displaying this result.
[0012]
In this way, in the intranet 600, requests from a plurality of client PCs 616 are processed by the WWW server 618 operating on the application server 612, and business processing using the RDBMS 622 is performed by returning the results to the browser on each client. .
[0013]
[Problems to be solved by the invention]
However, as described above, it seems that the componentization and reuse of an important program for developing a system using the Java servlet engine 620 in such a system has reached the limit as long as the conventional tag language is used. It is. In the conventional programming language, the part to be partized is a part that can be cut out independently of the application. For this reason, a program including business logic could not be made into parts. For example, system componentization has remained at about 20% of the total.
[0014]
In particular, a company's core business system handles a database, but each database item is given a unique name. Therefore, such a unique name is embedded in the program that handles the database. The name changes as the business is different and the database changes. For this reason, it is difficult to reuse a program created in one system in the development of another system. If the program that processes each item in the database can be made into parts, it will be possible to make parts and reuse them, and the efficiency of program development will be improved.
[0016]
  This inventionPurpose ofIs an application that can make program parts for processing each item in the database and reuse them more efficientlyServer systemIs to provide.
[0017]
[Means for Solving the Problems]
  Of this inventionis thereaspectApplication server system according to store databaseThe databaseConnected to the deviceAn application server system,The data item corresponding to each item constituting the record of the database is associated with the item name used to refer to the data item, and the application server system provides the client device that displays the screen using the data item. Are also connected,Input means for receiving an input of a request to display a screen from a client device;Item name for display of data items on the screenuseCodedProgram andDefined for each itemStorage means for storing item objects,The field object isData item attributesWhen,itemIn nameCorrespondingdataitemMethods to manipulateMethod program code corresponding toTheThe attribute includes an item name and an item name displayed on the screen, and the program includes a component program that constitutes a source for displaying the screen on the client device,Computation means for executing a program and processing corresponding to the item object, the computation means,By running the programBased on requestData item used to display the screenIdentifyitem nameThePart programMeans to give and itemsCorresponds to a data item by executing a part program based on the nameSearch means for searching for item objects;By executing the part program,Included in item object searched by search meansItem NameAnd methodsProgram codeAnd acquisition means for acquiring and acquired by the acquisition meansItem name andThe methodIncluding the item name by executing the part program using the program codeFor displaying the screenSourceGenerating means for generatingSource generated by the generation meansIs further provided.
[0019]
  Preferably,The computing means accesses the database based on the session variable obtaining means for obtaining information from the client apparatus, the data obtaining means for obtaining data transmitted from the client apparatus, and the data obtained by the data obtaining means. Access means.
[0021]
  Preferably,The input means further accepts input of update data input in the client device, and the calculation means further includes an update means for updating a data item stored in the database based on the update data..
[0023]
  Preferably,The attribute further includes the data type of the data item, and the method includes logic to perform error checking of the data item based on the data type..
[0025]
  Preferably,The data definition of the field object is based on the data definition of the data base.
[0027]
  Preferably,The generation unit generates a source for displaying a screen for correcting the item object.
[0029]
  More preferably,The generation means generates a source based on the tag language.
[0043]
DETAILED DESCRIPTION OF THE INVENTION
Conventionally, the Java language, which has not been put into practical use due to a slow response speed, is increasingly used mainly in the United States in the form of a servlet that moves a Java VM (Virtual Machine) on the server side. The Java language has the following features.
[0044]
(1) It operates on a wide range of platforms, and is easily compatible with Linux, which is expected as a next-generation OS (Operating system).
[0045]
(2) Many vendors provide tools with a common API (Application Programming Interface) and do not depend on tool vendors of only one company.
[0046]
(3) It is an object-oriented language and has a program reuse mechanism such as differential programming.
[0047]
As described above, since the Java language has characteristics consistent with the object of the present invention, the Java language is adopted in the system of the present embodiment. However, the present invention is not applicable only to a system using the Java language, and any programming language may be used as long as it is an object-oriented language. For example, C ++ and object pascal.
[0048]
In the present invention, what is called an “item object” defined for each item constituting a record in the database is used as a characteristic “object” in program development and program execution in an object-oriented language. It was. The details of the contents of the item object will be described later. Here, the item object has not been considered heretofore and is novel in the present invention, and the item object is used for program development for the purpose of program development. It should be pointed out that the program componentization was greatly promoted.
[0049]
The Java language is an object-oriented language, and the program can be reused in two aspects: a component and a framework.
[0050]
Here, the component is the same as a conventional method, and a part common to a plurality of programs is extracted, and is called from another program and reused. In general, parts are often independent of business logic.
[0051]
On the other hand, a framework is a collection of programs including a main routine and business logic. For example, the order receiving framework described below implements general order receiving, and can be used as it is, or can be reused by adding a unique function by differential programming. In the present invention, on the other hand, an item object is introduced to abstract a name unique to a database and the like, thereby making it possible to construct a part to be implemented as a common logic common to business programs as a framework. Therefore, according to the present invention, the program can be reused in a wider range beyond the range of conventional componentization.
[0052]
FIG. 1 shows the appearance of a personal computer for developing the system of the present invention. As will be described below, the personal computer may have a general configuration. The computer on which the application server realized by the program developed according to the present invention operates may be a general computer, and may be the same as that shown in FIG.
[0053]
Referring to FIG. 1, this computer system includes a computer 100 including a CD-ROM (Compact Disc Read-Only Memory) drive 110 and an FD (Flexible Disk) drive 112, a display 102, a printer 104, and a keyboard 106. And a mouse 108.
[0054]
FIG. 2 is a block diagram showing the configuration of this computer. As shown in FIG. 2, in addition to the CD-ROM drive 110 and the FD drive 112, the computer 100 stores a CPU (Central Processing Unit) 116 connected to the bus 126, an operating system boot-up program, and the like. ROM (Read Only Memory) 118, RAM (Random Access Memory) 120 for loading a program to be executed and storing data during program execution, and the created program are stored in a nonvolatile manner And a network interface 130 for connecting the computer 100 to a network 132. A CD-ROM 122 is attached to the CD-ROM drive 110. An FD 124 is attached to the FD drive 112.
[0055]
As described above, this program development system is realized by computer hardware and software executed by the CPU 116. Generally, such software is stored and distributed in a storage medium such as the CD-ROM 122 and the FD 124, read from the storage medium by the CD-ROM drive 110 or the FD drive 112, and temporarily stored in the hard disk 114. Further, it is read from the hard disk 114 to the RAM 120 and executed by the CPU 116. The computer hardware itself shown in FIGS. 1 and 2 is general. Therefore, the most essential part of the present invention is software stored in a storage medium such as the CD-ROM 122, the FD 124, and the hard disk 114.
[0056]
Since the operation of the computer itself shown in FIGS. 1 and 2 is well known, detailed description thereof will not be repeated here.
[0057]
Of course, it is also conceivable to operate a computer similar to the computer described above as an application server. In this case, the role of each component described above is the same as that described above.
[0058]
[Examination of Java framework]
In the general intranet shown in FIG. 32, the HTTP protocol is used between the browser 630 and the application server 612. The HTTP protocol is a sessionless (stateless) protocol. The screen displayed on the browser 630 is composed of HTML. HTTP and HTML are specifications developed for browsing information, and it has been found that when building a backbone system, it becomes a factor that deteriorates productivity.
[0059]
Since the HTTP protocol used in the intranet is sessionless, communication between the browser 630 and the application server 612 is disconnected every time. However, in the basic system, it is necessary to transfer the logged-in user information between pages displayed on the browser 630, and it is necessary to create some kind of session management mechanism.
[0060]
In addition, because of sessionlessness, the order of transition between screens displayed on the browser 630 is not guaranteed. Therefore, it is possible to specify a URL (Uniform Resource Locator) from the user side and directly access a screen that should be displayed in the middle of a series of flows or display a screen without access authority. there is a possibility. In order to prevent such a situation, each program checks whether the screen displayed on the browser 630 is in the order of transition assumed at the time of design, or the displayed screen is based on a predetermined authority. It is necessary to check whether it has been accessed.
[0061]
In addition, illegal data may be transmitted to the application server 612 due to a user operation error. For example, if a button (called a “Submit” button or the like) prepared to give an instruction for finally sending data to the server is accidentally pressed twice, the data is transmitted to the server twice. It will be. For this reason, there is a possibility that the data will be processed twice in the server if some measure is not taken, but a mechanism for preventing such malfunction is also required.
[0062]
Furthermore, in a normal client & server system, a screen can be designed by GUI (Graphical User Interface). However, in an intranet system, coding for outputting HTML for screen display must be performed manually. . That is, in the intranet system, for all data items used on the screen, the item name, input format (text box, radio button, etc.), number of input digits, etc. must be specified in the source code. For this reason, it is inevitable that the number of man-hours is increased as compared with system development using a normal GUI. In addition, HTML output codes and business logic codes often coexist, which is a factor that obstructs program componentization.
[0063]
If a program is created while taking these factors into account, a significant decline in productivity is inevitable. Not only that, there is also concern about quality degradation due to omissions during program creation. Therefore, we decided to solve these problems inside the framework and build a framework so that high-quality programs can be easily created without the programmer's particular awareness.
[0064]
[Functions required for the framework]
The framework is likely to be the basis for all future systems developed. Therefore, it is necessary to avoid situations where major changes are made after the framework has been released. As a result of examining the functions that the framework should have so that it can be applied to any system developed in the future, it was decided to implement the following functions as a framework.
[0065]
(1) Concealing intranet-specific problems
It hides the factors of productivity deterioration in the intranet system as described above so that programmers can develop programs without particular awareness.
[0066]
(2) Multilingual support
With the globalization of business, the number of cases where a company has a subsidiary overseas is increasing. Even in such a case, it is desirable to use the same system both domestically and overseas, but there is a problem of the language used. The usual approach is to first create a Japanese version of the program and then translate the necessary parts of the program (item names, messages, etc. displayed on the screen) into a foreign language (eg English). Let's go. However, in that case, one program is substantially realized by two separate programs. It is clear that having such a program doubles the maintainability of the program. Therefore, a program development technique that can handle multilingual languages without deteriorating the maintainability of the program is desired.
[0067]
Therefore, in this system, we decided to implement a mechanism for switching the language by specifying parameters at the time of program execution by incorporating not only Japanese but also foreign language resources into one system in advance. Such a function can be easily realized by using an item object as described later.
[0068]
By implementing such a mechanism as a framework, for example, it is possible to easily develop a program overseas where the labor cost of program development is low, and to translate it into Japanese.
[0069]
(3) Customizing item names
It is common for a company to package a system developed for itself and sell it externally. However, in that case, there is a strong need to customize, for example, the item names of the database used in the system according to the usage pattern in the purchasing company. Therefore, in this system, in order to satisfy such needs, we decided to implement functions for that purpose in the framework. This function can also be easily realized by using item objects.
[0070]
[Type of program reuse]
When considering the reuse of programs, there are various granularities such as those that use the entire program as it is, those that are reused at a simple subroutine level for data processing, and so on. Therefore, when we examined what types of program reuse were possible, the following four categories were classified.
[0071]
(1) Parts
A component is the smallest unit of program reuse. Parts are called and used by business applications.
[0072]
(2) Program pattern
A program pattern refers to a program that does not include business logic combining components. Data items used in the program pattern can be given as parameters. It can be used for basic table maintenance.
[0073]
(3) Framework
A framework is a collection of reusable programs that combine parts and program patterns and incorporate basic business logic. Programs in the framework can be reused while adapting to actual work by using a differential program according to the system to be used.
[0074]
(4) Package
A package is a reuse form in which the entire system is reused as it is.
[0075]
In order to realize this embodiment, parts are first developed, and development proceeds in the order of program patterns and frameworks. As a result, the concept of item objects, which will be described in detail later, has been reached. In the following, a technique for constructing an intranet system using item objects, and the structure and operation of such an intranet system will be described.
[0076]
[System development procedure]
With reference to FIG. 3, the development procedure of this system is as follows. First, an item object is created based on the configuration of the database to be processed (140). Then, an application program is created using the item object thus created (142). Next, an application server of the intranet system is realized by executing the application thus created (144).
[0077]
Item object
Referring to FIG. 4, item object 150 is an object set corresponding to each item in the database. An example of the item object is the item object 150A corresponding to the data item “order number” in the case of order receiving work. The item object 150A is an object class in the program development process, and an instance of this item object is formed and used for program execution during program execution.
[0078]
Since the item object 150 is an object class, as shown in FIG. 4, in addition to the item name (for example, “OrderNum”), the item name (Japanese name, English name, name in other languages, etc.), data length as properties , Abstracting data items such as data type (numeric type, string type, etc.), input format (text box, radio button, check box, pull-down list, pull-down menu, combo box, slider, etc.), corresponding DB column name, etc. Attributes that should be provided in general, and whether the input data is correct (for example, when the data type is numeric, whether the input data is numeric, whether the number of digits is within the data length, Etc.) in the form of methods.
[0079]
Table 1 shows the attributes, methods, etc. of the item object.
[0080]
[Table 1]
[0081]
In Table 1, “item name” is a name used to refer to this data item during coding of the program. Normally, the column name corresponding to this item object in the DB is used, and consists of only alphabets and some symbols.
[0082]
The “item name” refers to a name displayed on the screen when the program is executed. In the present embodiment, five types of item names can be set. Therefore, when the item name is used for the screen display, the item name can be displayed by switching the display from six ways.
[0083]
The meanings of the other elements shown in Table 1 will be apparent to those skilled in the art and will not be further described here.
[0084]
[Extract item object definition from DB definition]
The item object is prepared in the form of a text in the form of a Java language class definition source program in the program development system of the present embodiment. Since the item object has a deep relationship with the database, it is convenient to define the data of the item object as it is from the database definition.
[0085]
FIG. 5 shows a simple system block diagram of such a program development system. It goes without saying that this system can actually be realized by a general personal computer as shown in FIGS.
[0086]
Referring to FIG. 5, this system creates a database 166 from DB definition information 160 prepared in advance in a text format, or uses a prototype of the definition of item objects corresponding to each item in the database 166 from DB definition information 160. A data definition 168 is output in a text format, the content of the data definition 168 is modified by interactive processing using the display 102, the keyboard 106, and the mouse 108, and the class definition of the item object is changed from the modified data definition 168. A DB creation tool 162 that performs processing for outputting a file of a Java source 164 for the purpose.
[0087]
An example of the contents of the DB definition information 160 is shown in FIG. An example of the data definition 168 is shown in FIG. The data definition 168 shown in FIG. 7 is created based on information extracted from the line starting with “order number” immediately after the “/ Record” statement in the DB definition information 160 of FIG. Necessary items are supplemented. Each line includes a keyword indicating an attribute (for example, “/ LANG”, “/ INPUTTYPE”, etc.) and attribute contents corresponding to the keyword. At this time, the process of adding the original form of program coding corresponding to a method such as data check to the contents of the data definition 168 is also performed.
[0088]
By creating the data definition 168 from the DB definition information 160, the man-hours for creating the item object can be minimized.
[0089]
FIG. 8 shows a schematic flowchart of a program for creating the data definition 168 from the DB definition information 160. Referring to FIG. 8, first, the DB definition file designated by the programmer is opened (180). Next, the first line of this file is read (182). It is determined whether or not the content of the line is “/ RECORD” (184), and the processes of steps 182 and 184 are repeated until the content of the read one line becomes “/ RECORD”.
[0090]
When one line of “/ RECORD” is read, the data definition 168 is created and output for each line of the DB definition thereafter. Specifically, first, the next line of the DB definition information 160 is read (186), and it is determined whether or not the content of the line is “/ END”. If it is not “/ END”, a data definition 168 is created from the contents of the read one line, output as an item object file (190), and the next line is read (186). If the content of one line read is “/ END”, it means that all DB items in the DB definition information 160 have been processed, so the DB definition file is closed (192) and the process is terminated. .
[0091]
The processing in step 190 is determined based on the correspondence between the DB definition format and the data definition 168 format. Since the contents depend on the system and are obvious to those skilled in the art, the details are not described here.
[0092]
Of the functions of the DB creation tool 162 shown in FIG. 5, processing for interactively correcting the contents of the data definition 168 will be described with reference to FIGS. Although depending on the system to be developed, the number of item objects may reach several thousand, so it is desirable that the data definition 168 can be modified efficiently.
[0093]
Referring to FIG. 9, in the system according to the present embodiment, “item object edit” is selected from a pull-down menu displayed by selecting generation menu 204 from menu 202 on basic screen 200 of DB creation tool 162. When the menu item 206 is selected with the pointer 208, processing for correcting the data definition 168 is started. Thereby, the data definition selection screen 210 shown in FIG. 10 is displayed.
[0094]
In the upper part of the data definition selection screen 210, an alphabet selection button row 212 composed of buttons corresponding to alphabets A to Z is displayed. By selecting, for example, the button 214 corresponding to “U” with the pointer 208, a list of item objects having item names starting with the alphabet is displayed in the data definition list field 216.
[0095]
Referring to FIG. 11, in this screen 220, the data definition corresponding to the item to be corrected among the item names displayed in data definition list field 216 (for example, data definition field 222 corresponding to “UserID”) is displayed. By selecting with the pointer 208, the content of the selected data definition is displayed as an item object information correction screen. An example of the display at this time is shown in FIG.
[0096]
Referring to FIG. 12, item object information correction screen 224 displays a list of item object information corresponding to the selected data definition. After these contents are corrected, when the update button 228 is pressed, the original data definition file is overwritten with the updated information.
[0097]
The processing shown in FIGS. 9 to 12 can be developed with a program development tool using a normal GUI. Since the contents of the processing performed by these screens are simple, details of the program for realizing these screens will not be described here. However, it will be clear to those skilled in the art how to update the data definition file using these screens.
[0098]
[Structure of application program]
Next, the structure of an application using item objects prepared in this way will be described. This description will make it clear to those skilled in the art how to create such applications.
[0099]
FIG. 13 shows an example of a screen realized on the client PC by the application server. This example is a program for maintaining a user DB (user table). Referring to FIG. 13, user table maintenance screen 230 includes an inline menu 240, a button 242, and an input form composed of a plurality of item-specific lines including item names 244 and item fields. The function of the application server is to create an HTML source for displaying this screen by the browser on the application server, send it to the client PC for display, and update the user table according to the input data sent from the client PC. .
[0100]
Conventionally, it has been difficult to reuse the main input form part on this screen in a program different from the user table maintenance, for example, the department registration screen. This is because item names unique to the user registration program such as user ID and name are embedded in the user registration program. However, by introducing item objects, the attributes of such data items can be separated from the program, and the form part can be reused.
[0101]
FIG. 14 simply shows the system configuration of the WWW server 250 that constitutes the application server of this intranet system. Referring to FIG. 14, the WWW server 250 includes a Java servlet engine 260 for processing requests from browsers 254, 256, etc. operating on a plurality of client PCs via a network 252, and a Java servlet engine 260. Main program 262 for processing a request from a client browser given by the user, a session variable object 264 for storing a session variable 270, 272 and the like prepared for maintaining a session for each client by the main program 262, and a main program And a memory space 266 for storing item objects 280 and 282 to be referred to when executing H.262.
[0102]
The main program 262 includes a form part 290 that constitutes a part transmitted to the client. Then, as will be described later, an HTML source for forming a desired form is formed by selecting a data item to be displayed on the form component 290 from among the item objects in the memory space 266 and transmitted to the browser of the client PC. . Since no data items are embedded in the form part 290 itself, the form part 290 can be reused for another program. The logic part of functions (registration, deletion, change, etc.) to be implemented by the user table maintenance program can also be used for the maintenance of other DB tables. Because it only needs to be changed, the program can be reused more efficiently.
[0103]
A functional structure to be implemented by the WWW server 250 is shown in FIG. Referring to FIG. 15, WWW server 250 includes a Java program that is activated in response to a request from browsers 254 and 256. This program (main program 262) acquires the login information and the previous screen information from the session variable 270, the session variable acquisition unit 300 for checking the access authority and the legitimacy of the screen transition, browsers 254, 256, etc. Form / URL variable acquisition unit 302 for acquiring data transmitted from the browser (for example, an input order number), and an SQL assembly unit for assembling SQL (Structured Query Language) based on the acquired data 304, an SQL execution unit 306 for executing the assembled SQL and accessing the database 166, and a data processing unit for performing processing such as format conversion on the data acquired from the database 166 as necessary 308 and get this way An HTML output unit 310 that performs processing for transmitting the received data to the browsers 254, 256 and the like together with the HTML tag, and a session variable storage unit 312 for storing the session variable 270 for the next access are included.
[0104]
Except for programs that perform processing that writes data files in a special format in order to link with a specific program, most programs perform processing in the order described above. If each processing unit shown in FIG. 15 is used as a basic component and a necessary number of components are prepared in advance, the programmer can efficiently find and combine components corresponding to functions to be realized by the program he / she wants to create. You can create a program. Also, by preparing the entire processing unit as a framework, the program can be completed simply by adding necessary business logic.
[0105]
[Screen output using item objects]
FIG. 16 shows an outline of a screen output (HTML source output) mechanism using item objects stored in the memory space 266. Referring to FIG. 16, main program 262 gives information specifying items used on the screen to form component 290. The form component 290 searches the memory space 266 for an item object corresponding to the item given from the main program 262. Since the item object includes all information relating to the data name and data length to be displayed on the screen, the form component 290 obtains the information from the item object, thereby providing the HTML to be given to the browsers 254, 256, etc. You can create a source. By transmitting the created HTML source to the browsers 254, 256, etc., the screen shown in FIG. 13 is displayed by the browser operating on the client PC.
[0106]
Since information on the name, data length, data format, and the like of the displayed item is acquired from the item object, the information is not coded in the main program 262. An example of a part of the main program 262 is shown in FIG. Referring to FIG. 17, in the program of main program 262, first, constant “p_fields”, which is a list of item object names to be used in this processing, is defined in parameter definition line 320, and the form in the later logic In the CALL instruction 322 for calling a part, this constant is passed as a parameter to the form part. That is, the designation of the item object directly connected to the business is only seen in the parameter definition line 320.
[0107]
In this case, the parameters given to the form part 290 by the main program 262 are {userid, username, furigana,. . . }, By simply changing these parameters to a list of names of other item objects, it is possible to realize a completely different screen display using the same main program 262 logic and the same form part 290. .
[0108]
FIG. 18 shows the logic of the program constituting the form part in the form of a flowchart. Among the given parameters, the following processing is performed one parameter at a time from the beginning. That is, for the parameter, an item object specified by the parameter is referred to, and an HTML source corresponding to a form part for inputting the item from information such as an item name and a data length is created (330).
[0109]
Subsequently, it is determined whether or not all parameters have been processed (332), and steps 330 and 332 are repeated until all parameters are processed.
[0110]
If it is determined that all parameters have been processed, the HTML source created by the above processing is output to the browser 254 and the like, and the processing is terminated.
[0111]
Thus, item-specific information is not coded in the main program logic. As a result, the main program can be reused in common in various processes. Also, since the form part 290 itself is separated from the item-specific information, the form part 290 can be reused in common in various processes.
[0112]
As described above, according to the present invention, by using the item object, the user interface is separated from the program and succeeded in componentization. Furthermore, by implementing the error check and DB update logic of the item in the item object as a method, the program part directly connected to the business can be made into a component.
[0113]
In addition, since there is a concern that the response speed of the WWW server 250 may be lowered by implementing the item object, the item object (instance) that has been used once is made resident in the memory, and the next request is processed. We decided to reuse. As a result, it was confirmed that there was almost no deterioration in response time due to the use of the item object or it was well within the allowable range.
[0114]
[Building a framework]
FIG. 19 schematically shows the structure of the basic framework. Referring to FIG. 19, the basic framework 340 includes a session variable acquisition unit 342, an authority check unit 344, a DB connection acquisition unit 346, a main processing unit 348, a DB connection return unit 350, and a session variable storage unit 352. Among these, the session variable acquisition unit 342, the authority check unit 344, and the session variable storage unit 352 correspond to the session variable acquisition unit 300, the session variable storage unit 312 shown in FIG. The DB connection acquisition unit 346 and the DB connection return unit 350 are for establishing a connection with a DB prior to referring to and updating a database (not shown) and returning the connection to the connection pool after processing. In this embodiment, in order to shorten the connection time with the DB, a plurality of DB connections are established in advance, and these connections are assigned to these requests according to the request. Is taken back to the pool.
[0115]
In the basic framework 340, portions other than the main processing unit 348 are mounted in advance, but nothing is mounted on the contents of the main processing unit 348. The program part 360 to be developed is implemented by differential programming for the main processing unit 348. Therefore, the programmer does not need to be particularly aware of the session management and connection management parts.
[0116]
The program part 360 to be developed includes a form variable acquisition unit 362, an SQL assembly unit 364, an SQL execution unit 366, a data processing unit 368, and an HTML output unit 370. These correspond to the Form / URL variable acquisition unit 302, the SQL assembly unit 304, the SQL execution unit 306, the data processing unit 308, and the HTML output unit 310 shown in FIG. Several parts are prepared in advance for these parts, and the programmer can select and use the necessary parts. As a result, the coding amount of the main process can be greatly reduced.
[0117]
Item Object Management
As described above, the item object defines the database item itself as an object class, and is configured to be instantiated and resident in the memory when the application is executed. At this time, if an instance of the item object is individually generated for a large number of requests, memory is wasted. Therefore, in the system of the present embodiment, a class for managing the item object is provided, Only one item object instance is generated for each item in the database by an object which is an instance of this class, and this instance is shared by a plurality of applications.
[0118]
FIG. 20 shows this concept. Referring to FIG. 20, application programs 382, 384, and the like issue a request for item object 386 to object 380 for item object management when it is desired to use an item object (for example, item object 386). In response to this request, the item object management object 380 checks whether or not the item object 386 is in memory, and if so, returns the item object 386 to the requesting application. The application (for example, the application program 382) that has received the item object 386 performs the above-described processing using the item object 386 thus received. When a request for an item object is received and the corresponding item object does not exist in the memory, the object 380 for managing the item object generates the object and returns the item object to the application.
[0119]
Here, the process of “returning the item object” means that in C ++ or the like, a pointer on the memory of the object is returned to the application as a return value. In the case of Java, since the pointer is hidden, such processing is simply called “return object”.
[0120]
With reference to FIG. 21, a process executed by the object 380 for managing item objects will be described. The object 380 for managing item objects determines whether there is a request for an item object from the application (400), and waits until there is a request. As an actual mounting format, the following processing is a method for returning the item object to the application, which is provided in the object 380 for managing the item object. Therefore, the application need only call this method of the object 380 for managing the item object with the item object name that it needs as a parameter.
[0121]
When called by the application (YES in step 400), it is determined whether the requested item object is in memory (402). Actually, the object 380 for managing the item object maintains a management table for the generated item object, and when the item object name exists in this management table, the item object exists in the memory. When the item object name does not exist in the table, it is determined that the item object has not been instantiated yet.
[0122]
If it is determined that the requested item object is not in memory, an instance of the requested item object is generated (404). Then, the item object is added to the management table (406). Then, the process proceeds to step 408. On the other hand, if it is determined in step 402 that the requested item object already exists in the memory, the control proceeds directly to step 408.
[0123]
In step 408, the item object thus created or the item object found on the management table is returned to the application that requested the item object, and the process returns to the process (400) waiting for the next request again.
[0124]
The function of the object 380 for managing the item object is implemented by the method having the control structure as described above.
[0125]
[Effect of componentization]
As described above, in the system development environment according to the present embodiment, the framework, common parts, and item objects can be made into parts and reused. As shown in FIG. 22 (1), in the conventional method of componentization, the proportion of the common component 424 in the entire program 420 is quite low, and the portion of the individual program 422 that must be created individually for each application Showed a relatively large specific gravity. On the other hand, according to the present invention, by mounting the item object 438 in a lower layer part than the part, information and methods corresponding to the data items can be removed from each part and can be collectively defined in the item object. Became. As a result, each component of the common component 436 is slimmed, and moreover, it is not necessary to mount business-specific logic on each component, so that the range of componentization has expanded.
[0126]
In addition, the implementation of the item object 438 eliminates the need to describe the data name and the number of data digits in the application program. As a result, it is possible to separate the application program from the data and make it more abstract, and it is possible to prepare a framework 432 for reuse. As a result, the specific gravity of the portion of the individual program 434 that must be individually programmed is relatively small.
[0127]
In addition, since the data definition, data operation methods, etc. are collected in the field object, the data object, the number of digits of data, the error check method, etc. can be changed according to the user's request. The change of was ended. Since there is no need to change the application program body, there is less risk of bugs due to program changes accompanying changes in user requirements, and quality can be improved. Since the data name can be changed in the item object according to the user's work, the effect that customization is easy was obtained.
[0128]
Further, a plurality of types of item names are prepared for the item object. For example, the first item name is set to Japanese, the second item name is set to English, and the logic is such that a specific item name is selected according to a given parameter when the program is executed. Then, the language of the application program can be easily switched by changing only the parameters at the time of execution without changing the logic of the program itself. If a similar mechanism is prepared for all parts that require processing in multiple languages such as error messages, the language can be completely switched.
[0129]
As described above, in the present embodiment, the concept of an item object is introduced, the structure of the application program is changed by mounting the item object, and as a result, the range of componentization can be expanded. As a result, the amount of individual programs can be further reduced by preparing a framework.
[0130]
[Create reusable program]
The point of framework construction is program reuse. However, there is a certain disadvantage in differential programming by inheritance, which is a feature of object-oriented languages. That is, in inheritance, a new program is added that overwrites a part of the original program, but in order to do so, all internal structures of the inheritance source program must be understood. Otherwise, as a result of overwriting, the operation of the whole program may become strange.
[0131]
Further, when the inheritance source program is modified, there is no guarantee that the overwritten program operates normally. For example, if the name of the overwritten method is changed in the inheritance source program, the overwritten program will not work properly.
[0132]
Therefore, it is necessary to apply differential programming by inheritance in consideration of maintainability. As a result, it is not always easy to apply differential programming to business programs that need to be maintained as needed to improve the business content. In particular, in a system in which a business program operates, the number of programs may be hundreds to thousands. In that case, the number of system engineers and programmers who do the work increases, and it is difficult to design and manufacture programs while taking into account differential programming through inheritance, both in terms of securing human resources and ensuring development deadlines. is there.
[0133]
Therefore, in the system of this embodiment, the programming framework is based on item objects as described in the first embodiment, and the program is further modularized and necessary modules can be freely combined. A mechanism for developing and changing programs was adopted.
[0134]
[Modular configuration]
FIG. 23 shows an overall image of the internal structure relating to the transition of the screen shown in FIG. 13 in this system. Referring to FIG. 23, in this system, a transition can be made from main program 450 to inquiry module 452, registration module 454, update module 456, and deletion module 458. Each module is provided with one or a plurality of page processes 460, 462, 464, 466, etc., and by calling each module by specifying a page number from the main program 450, the designated page of the module is displayed. It has come to be.
[0135]
FIG. 24 shows an internal structure of a system for realizing the page transition as described above in the present embodiment. Referring to FIG. 24, this system receives parameters from main program 470, inquiry module 472, registration module 474, update module 476, delete module 478, and main program 470, and executes the specified module. And a controller 480 for controlling each module to display a designated page. The controller 480 is also an instance of a class called a controller class.
[0136]
The inquiry module 472 to the delete module 478 are all generated by the main program 470, but the controller 480 is also instantiated by the main program 470. The controller 480 manages a management table in which modules 472 to 478 generated by the corresponding main program 470 are registered. When parameters are given from the main program 470, a relatively simple algorithm as described below is used. Controls to display an appropriate page of an appropriate module.
[0137]
FIG. 25 shows a basic structure of each module such as the inquiry module 472. These modules are also generated as instances of the respective classes when the program is executed. As shown in FIG. 25, for example, the inquiry module 472 provides various properties 490 including a menu display character string, parameters, and the like, a method for adding a menu display character string to the menu using these properties, and a main program 470. One or a plurality of methods 492 including a page control method for performing processing for displaying an appropriate page in the module if there is an appropriate page in the parameter, a first page processing method, a second page processing method, etc. Including.
[0138]
Throughout all modules, the page number corresponding to the page processing method is basically unique. Accordingly, when the controller 480 is activated by specifying a certain page number with the main program 470, a page processing method corresponding to the page number is uniquely determined and executed. However, as will be described later, page numbers may be overlapped, but in that case, only one of them (the one registered last in the controller 480) is executed. Such a mechanism has an effect of easily exchanging page processing, and details thereof will be described below.
[0139]
FIG. 26 shows an outline of the processing of the main program 470 in the form of a flowchart. Referring to FIG. 26, the main program 470 first generates all instances of modules used in its own processing (500). Next, the main program 470 generates an instance of the controller 480 (502). A module registration method mounted in advance in the controller 480 generated in this way is called, and all modules instantiated in step 500 are registered in the controller 480. At this time, the controller 480 stores information regarding the module registration order.
[0140]
Subsequently, a request from the browser executed on the client PC is waited (506), and if there is a request, a page number to be processed corresponding to the request is designated, and a module execution method of the controller 480 is called. After sending the result to the browser, control returns to step 506.
[0141]
In FIG. 27, when there is a call of its own method, the controller 480 determines which call has been made (520), and executes the execution method 522, the registration method 524, etc. according to the result. In the registration method, information for specifying an instance of a module generated by the main program 470 is registered in the management table. At this time, as described above, information regarding the registration order is also held.
[0142]
FIG. 28 shows details of the execution method 522. First, a process for creating a menu displayed on the screen is performed (530). This process will be described later with reference to FIG.
[0143]
Subsequently, the modules are sequentially called in the order newly registered in the management table by the registration method shown in FIG. At this time, a page number is given to each module as a parameter. As will be described later, each module executes a page processing method that matches the given page number and returns a result of “processed”, and there is no page processing method that matches the given page number. Do nothing and return a result of "unprocessed". The controller 480 determines whether or not the result of “processed” is returned from the module as a result of the process of step 532, and when the result of “unprocessed” is returned, the process of step 532 is performed for the next module. Repeat. When the “processed” result is returned, the execution method is finished.
[0144]
FIG. 29 shows the contents of step 530 in FIG. Referring to FIG. 29, controller 480 first creates an empty menu tag (string) and passes it to the first module in the registration table (550). When each module receives the menu tag, it adds it to the menu tag of its own menu display character string and returns it to the controller 480. The controller 480 receives the menu tag from the module (552), and determines whether or not this processing has been performed for all the modules (554). If the processing has not been completed for all the modules, the controller 480 passes the menu tag to the next module (556), and thereafter repeats the processing of steps 552 to 554.
[0145]
When the menu tag is passed to all modules and the receiving process is completed, a process of passing the menu tag obtained as a result to the browser is performed (558). By this processing, the menu display character strings possessed by the modules are displayed side by side in a menu format on the browser screen.
[0146]
Now, each module called by the controller 480 in Step 532 of FIG. 28 executes the following page execution method. Referring to FIG. 30, first, the module determines whether or not a page corresponding to the page number given from controller 480 as a parameter is in its own module (570). If there is, the page is executed (572), and the result of “processed” is returned. If not, do nothing and return an “unprocessed” result.
[0147]
As described above, modules are called back in order from the module newly registered in the table. As a result, when there are a plurality of modules having the page processing method with the same page number, only the page processing method of the newly registered module is executed, and the page processing method of the old module is not executed. Thus, a specific page process can be replaced with a new one. This relationship is shown in FIG.
[0148]
Referring to FIG. 31, it is assumed that a new inquiry module 580 is added and registered in the system shown in FIG. Since this module 580 is newly registered from the inquiry module 472, it is called by the controller 480 before the inquiry module 472. Further, as shown in FIG. 31, the new inquiry module 580 has a page processing method 582 corresponding to the page number (11) in addition to the page control method, and this page number is included in the page processing methods of the inquiry module 472. It matches with one page number. Then, when calling the page number 11, the page processing method 582 of the new inquiry module 580 is first called. As a result, a “processed” result is returned from the new inquiry module 580 to the controller 480. The page processing (11) method of the inquiry module 472 is never called.
[0149]
In this configuration, even if the page processing (11) method of the query module 472 is changed, the page processing method 582 of the new query module 580 is not affected at all. Therefore, modules and page processing methods can be made independent, and a highly maintainable business program can be efficiently customized by a differential program.
[0150]
By developing a program with the module configuration as described above, the following effects can be obtained.
[0151]
(1) Since modules are independent in processing units, creation is easy and maintenance is easy.
[0152]
(2) Modules with necessary functions can be used in any combination.
(3) Modules can be easily replaced and added, making it easy to customize programs.
[0153]
Although the present invention has been described based on the embodiments, the present invention is not limited to the system of these embodiments. The scope of rights of the present invention should be determined by the description of each claim. What uses the component equivalent to each component of embodiment disclosed by this-application specification is also contained in the right range of this invention.
[Brief description of the drawings]
FIG. 1 is an external view of a computer for realizing a program development system according to the present invention.
FIG. 2 is a block diagram of a computer for realizing a program development system according to the present invention.
FIG. 3 is a flowchart showing an application program creation procedure in an embodiment of the present invention.
FIG. 4 is a schematic diagram for explaining a concept of an item object.
FIG. 5 is a block diagram of a tool for extracting item objects from DB definition information.
FIG. 6 is a diagram illustrating an example of a DB definition file.
FIG. 7 is a diagram illustrating an example of a data definition file of an item object.
FIG. 8 is a flowchart of processing for creating a data definition file of an item object from a DB definition file.
FIG. 9 is a diagram showing a screen when interactively modifying the data definition file of an item object.
FIG. 10 is a diagram showing a screen when interactively modifying the data definition file of an item object.
FIG. 11 is a diagram showing a screen when interactively modifying a data definition file of an item object.
FIG. 12 is a diagram showing a screen when interactively modifying the data definition file of an item object.
FIG. 13 is a diagram illustrating an example of a business application screen.
FIG. 14 is a diagram for describing the concept of an application server using item objects in an embodiment of the present invention.
FIG. 15 is a diagram for explaining functions to be implemented by an application server.
FIG. 16 is a diagram showing a relationship between an object and an application when an application using an item object operates according to an embodiment of the present invention.
FIG. 17 is a diagram illustrating a part of a coding example of a main program.
FIG. 18 is a flowchart of processing for realizing a form part.
FIG. 19 is a diagram illustrating a relationship between a framework and a program part to be developed.
FIG. 20 is a diagram for explaining a method of managing an item object using an item object management object.
FIG. 21 is a flowchart of processing for item object management;
FIG. 22 is a diagram for explaining the effect of framework construction according to an embodiment of the present invention.
FIG. 23 is a diagram showing the concept of module control according to an embodiment of the present invention.
FIG. 24 is a diagram showing the relationship between objects and applications for module control according to an embodiment of the present invention.
FIG. 25 is a diagram conceptually illustrating a configuration of a module.
FIG. 26 is a schematic flowchart of a main program incorporating module processing.
FIG. 27 is a flowchart for explaining the operation of a controller object.
FIG. 28 is a flowchart showing a control structure of an execution method of a controller object.
FIG. 29 is a flowchart of menu creation processing by a controller object.
FIG. 30 is a flowchart of a page execution method implemented in each module.
FIG. 31 is a diagram illustrating a relationship between an object and an application when page replacement is performed.
FIG. 32 is a block diagram illustrating a configuration example of a system constructed by a conventional intra network.
[Explanation of symbols]
150, 280, 282 Item object, 162 DB creation tool, 254, 256 Browser, 260 Java servlet engine, 290 Form parts, 470 Main program, 472 Query module, 474 Registration module, 476 Update module, 478 Delete module, 580 New query module.

Claims (6)

  1. An application server system connected to a database device for storing a database, wherein a data item corresponding to each item constituting a record of the database is associated with an item name used for referring to the data item The application server system is further connected to a client device that displays a screen that uses the data item,
    Input means for receiving an input of a request to display the screen from the client device;
    A storage means for storing a program coded using the item name for display of the data item on the screen, and an item object defined for each item;
    The item object includes an attribute of the data item and a method program code corresponding to a method for operating the data item corresponding to the item name,
    The attributes include the item name and the item name displayed on the screen,
    The program includes a part program that constitutes a source for displaying the screen on the client device, and the attribute of the data item and the part program are separately defined.
    Computation means for executing the program and processing corresponding to the item object,
    The computing means is
    Means for giving the part program an item name for identifying a data item used for displaying the screen based on the request from the client device ;
    Search means for searching for an item object corresponding to the data item by executing the component program based on the item name;
    An acquisition unit that acquires the item name and the method program code included in the item object searched by the search unit by executing the component program;
    Generating means for generating the source for displaying the screen including the item name by executing the component program using the item name and the method program code acquired by the acquiring unit;
    An application server system, further comprising a transmission unit that transmits the source generated by the generation unit to the client device.
  2. The computing means is
    Session variable acquisition means for acquiring information from the client device;
    Data acquisition means for acquiring data transmitted from the client device;
    The application server system according to claim 1, further comprising: access means for accessing the database based on data acquired by the data acquisition means.
  3. The input means further accepts an input of update data input in the client device;
    The application server system according to claim 1, wherein the calculation unit further includes an update unit that updates a data item stored in the database based on the update data.
  4. The attribute further includes a data type of the data item,
    The application server system according to claim 1, wherein the method includes a logic for performing an error check on the data item based on the data type.
  5.   5. The application server system according to claim 1, wherein the data definition of the item object is based on the data definition of the data base.
  6.   The application server system according to claim 1, wherein the generation unit generates the source based on a tag language.
JP2000143123A 2000-05-16 2000-05-16 Application server system Active JP4136271B2 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
JP2000143123A JP4136271B2 (en) 2000-05-16 2000-05-16 Application server system

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
JP2000143123A JP4136271B2 (en) 2000-05-16 2000-05-16 Application server system

Publications (2)

Publication Number Publication Date
JP2001325098A JP2001325098A (en) 2001-11-22
JP4136271B2 true JP4136271B2 (en) 2008-08-20

Family

ID=18649986

Family Applications (1)

Application Number Title Priority Date Filing Date
JP2000143123A Active JP4136271B2 (en) 2000-05-16 2000-05-16 Application server system

Country Status (1)

Country Link
JP (1) JP4136271B2 (en)

Families Citing this family (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2003308332A (en) 2002-04-15 2003-10-31 Sumitomo Electric Ind Ltd Program for accessing database, computer-readable recording medium recorded with the program, and method of operating database
JP4643900B2 (en) * 2003-11-05 2011-03-02 株式会社野村総合研究所 Input check system with check code generation function
JP4495782B2 (en) * 2004-02-25 2010-07-07 株式会社野村総合研究所 Data integration management system and data integration management program
US8539469B2 (en) * 2004-05-11 2013-09-17 Microsoft Corporation Efficient patching
JP4280759B2 (en) 2006-07-27 2009-06-17 キヤノン株式会社 Information processing apparatus and user interface control method
US8812962B2 (en) 2009-11-12 2014-08-19 Microsoft Corporation Web service interface and querying
KR101415424B1 (en) * 2011-03-02 2014-07-04 미쓰비시덴키 가부시키가이샤 Programmable display apparatus and image data creation method
JP5377695B2 (en) * 2012-02-29 2013-12-25 京セラドキュメントソリューションズ株式会社 Device information providing system, electronic device and device information providing program
JP5727413B2 (en) * 2012-05-08 2015-06-03 株式会社野村総合研究所 Application development support system and application development support program
CN105518633B (en) * 2013-08-29 2018-10-19 株式会社野村综合研究所 More equipment in Web server system, application and development auxiliary system, the multi-language support method in Web server system, Web server system support method and application and development householder method

Also Published As

Publication number Publication date
JP2001325098A (en) 2001-11-22

Similar Documents

Publication Publication Date Title
US5754845A (en) Portable and dynamic distributed applications architecture
CN1704900B (en) Method and apparatus for generating user interfaces based upon automation with full flexibility
US6016394A (en) Method and system for database application software creation requiring minimal programming
Ousterhout An X11 Toolkit Based on the Tcl Language.
CA2471615C (en) Framework for creating modular web applications
US7984424B2 (en) Isolating declarative code to preserve customizations
US7788238B2 (en) Extensible object-modelling mechanism
Ziadi et al. Software product line engineering with the UML: Deriving products
US7917888B2 (en) System and method for building multi-modal and multi-channel applications
US5432925A (en) System for providing a uniform external interface for an object oriented computing system
US7366723B2 (en) Visual query modeling for configurable patterns
US7509649B2 (en) System and method for conversion of generic services' applications into component based applications for devices
Tilley et al. Programmable reverse engineering
US6948151B2 (en) System and method for dynamic packaging of component objects
US7321918B2 (en) Server-side control objects for processing client-side user interface elements
CA2335127C (en) System and method for the visual customization of business object interfaces
US6105043A (en) Creating macro language files for executing structured query language (SQL) queries in a relational database via a network
US8015265B2 (en) System for designing and performing Web application
US6430609B1 (en) Method for accessing complex software applications through a client user interface
US6559861B1 (en) Displaying computer interfaces in multiple languages
US6163878A (en) Method and system for designing, generating and storing applications
US20030120659A1 (en) Systems for developing websites and methods therefor
US7120897B2 (en) User control objects for providing server-side code generation from a user-defined dynamic web page content file
US20040003119A1 (en) Editing files of remote systems using an integrated development environment
EP1156427A2 (en) Postback input handling by server-side control objects

Legal Events

Date Code Title Description
A131 Notification of reasons for refusal

Free format text: JAPANESE INTERMEDIATE CODE: A131

Effective date: 20050308

A521 Written amendment

Free format text: JAPANESE INTERMEDIATE CODE: A523

Effective date: 20050506

A02 Decision of refusal

Free format text: JAPANESE INTERMEDIATE CODE: A02

Effective date: 20050705

A521 Written amendment

Free format text: JAPANESE INTERMEDIATE CODE: A523

Effective date: 20050901

A911 Transfer of reconsideration by examiner before appeal (zenchi)

Free format text: JAPANESE INTERMEDIATE CODE: A911

Effective date: 20050914

A912 Removal of reconsideration by examiner before appeal (zenchi)

Free format text: JAPANESE INTERMEDIATE CODE: A912

Effective date: 20051007

A521 Written amendment

Free format text: JAPANESE INTERMEDIATE CODE: A523

Effective date: 20080326

A01 Written decision to grant a patent or to grant a registration (utility model)

Free format text: JAPANESE INTERMEDIATE CODE: A01

A61 First payment of annual fees (during grant procedure)

Free format text: JAPANESE INTERMEDIATE CODE: A61

Effective date: 20080603

R150 Certificate of patent or registration of utility model

Free format text: JAPANESE INTERMEDIATE CODE: R150

FPAY Renewal fee payment (event date is renewal date of database)

Free format text: PAYMENT UNTIL: 20110613

Year of fee payment: 3

FPAY Renewal fee payment (event date is renewal date of database)

Free format text: PAYMENT UNTIL: 20110613

Year of fee payment: 3

FPAY Renewal fee payment (event date is renewal date of database)

Free format text: PAYMENT UNTIL: 20120613

Year of fee payment: 4

FPAY Renewal fee payment (event date is renewal date of database)

Free format text: PAYMENT UNTIL: 20130613

Year of fee payment: 5

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250

R250 Receipt of annual fees

Free format text: JAPANESE INTERMEDIATE CODE: R250