KR20000030817A - Server-side component for view contents separation and dynamic liking generation method for web-application development based on MVC model - Google Patents

Abstract

PURPOSE: A servo component adapting view contents and real-time application for web page composition on the basis of MVC model is provided to make a CGI program by completely separating HTML files from Servlet program, a dispersed process by separating database from free presentation and overcome the degrade of performance due to the access of a plurality of users. CONSTITUTION: A package CMDHtml(com.addra) maintains and calls all functions of SQL processor(42) and HTML processor(41). The SQL processor generates and maintains a package connection pool for performing insertion, deletion, update, selection, etc. of all matters related to the database. The HTML processor processes parameters related to the functions for substituting table data with HTML content, processing of HTML files and Requests. In order to completely separate the HTML file contents from the corresponding language codes, the Servlet has only Java codes and the HTML is stored in the file system as template.

Description

Server-side component for view contents separation and dynamic liking generation method for web-application development based on MVC model}

The present invention relates to a component and an authoring tool that allow a CGI program to be created by completely separating HTML document content and code of a corresponding language. More specifically, in the present invention, a method of separating servlet code, which is Java's CGI interface, is studied using Java, and after separating servlet and HTML, the database includes a database in real time. The present invention relates to an authoring tool capable of dynamically outputting a screen by dynamically connecting various data and a template (ML).

The existing web program development method has many problems in the development method itself to meet the rapidly changing user requirements. The present invention has been proposed for the development and management of web programs to support rapid development in accordance with the user's requirements and to respond appropriately and promptly even when the requirements change later.

The rapid development of programs and the simplification of program sources aims to increase readability and to automate simple repetitive tasks for fast application in rapidly changing markets.

Existing world wide web (WWW) program production includes document content of ML (Markup Language, cf. HTML), which is the screen source to be displayed to clients, and the corresponding programming languages (perl, c, I have written CGI (Common Gateway Interface) using a mixture of both languages using Java. This has many problems and variables to separate HTML (HyperText Markup Language) due to the interface provided by the language.

The most problematic part of this form of writing is that the design of the designer is inserted into the source by the programmer, so the contents of the entire source code are complicated and lengthy, which leads to a decrease in development productivity and future maintenance. I had a problem that took a lot of time and effort to solve a problem (program bug, etc.).

In addition, CGI and Java applets are used to build a dynamic website. However, CGI has the disadvantage of rapid performance deterioration due to the increase of users, and applet due to the delay of loading speed. In order to overcome these shortcomings, the servlet technology running on the server side is in the spotlight, but the servlet has a disadvantage in that program development productivity is low and maintenance is difficult due to the combination of HTML documents and business logic.

Efforts to separate HTML document content from program code have been continually studied previously, and various formats have been published and are currently in use. The most popular formats are Active Server Pages (ASP), Java Server Pages (JSP), and Java HTML (JHTML). The common advantages of these formats are that you can write programs in the form of embedding program code into the HTML document content. To improve the readability.

However, the problem with using these formats is that they are tied to a platform, and ultimately, the HTML document content and program code are not separated, and thus the complexity of the logic and the difficulty of modularization are inherent.

In the case of Active Server Page (ASP), the web server must use Microsoft's Internet Information Server (IIS). In the case of Java Server Page (JSP), JSDK2.1 or higher or JSWDK1.0 must be used. JRUN 2.3 or later supports JSP Spec1.0. JHTML (Java HTML) can also be implemented using BEA's Web-Logic Application Server. That is, it has a disadvantage of being dependent on a specific platform.

Therefore, when the servlet program is written using the present invention, it is possible to create a program that does not depend on any platform while obtaining the same effect. The reason is that the same program can be written using only the most basic formats, JDK and JSDK, when writing servlets.

The present invention facilitates the separation work between the program developer and the designer. Accordingly, even after the maintenance, the modification can be applied to the template without recompiling the source only by changing the template.

In order to overcome the shortcomings of the conventional servlet, the present invention can easily separate the HTML document and the servlet program, thereby easily constructing, managing, and reusing the web-based information system, and greatly reducing the maintenance cost due to the easy understanding of the program code. It can also be achieved at the same time. In addition, distributed processing is possible by separating database linkage, presentation and work logic, and overcomes the performance degradation caused by multiple user access. This separation of logic makes it easy to configure n-tier and EJB in the future. The template also allows data formats such as characters, dates, times, and numbers, which were previously covered in the source code.

1 is a schematic diagram illustrating a conventional servlet operation method.

Figure 2 shows a schematic diagram of the Addra-WebCom configuration of the present invention.

3 is a schematic diagram showing the operation of the Addra-WebCom servlet of the present invention.

4 shows a component view of the present invention.

5 is a diagram illustrating an html package class diagram of the present invention.

Figure 6 shows the sql package class diagram of the present invention.

7 is a diagram illustrating a model package class diagram of the present invention.

8 is a creation screen of the design development tool of the present invention.

9 is an example to which the present invention is applied.

※ Explanation of Drawings

10: browser 20: web server 30: servlet server

40: Servlet 41: HTML Processor 42: SQL Processor

43: Base Servlet 50: RDB (Relational DateBase)

60: file system

The present invention handles the insertion, deletion, modification, selection, etc. of CMDHtml (com.addra), which is a class that manages / calls all functions of the SQL processor 42 and the HTML processor 41, and all matters related to the database. SQL processor (42: com.addra.sql), a package that creates and manages a connection pool to manage interworking, processing HTML document contents, replacing table data with HTML contents, and user requests (User HTML processor (41: com.addra.html), a package that handles parameters related to the request, and a model (com.addra.model) and a class related to servlets that take the contents of tables in the database and construct them into objects. Servlet package (comm.addra.servlet) provided, utility package (com.addra.util) that collects useful frequently used classes, and htmlElement package (com.addr) that contains each element of HTML as an object. It provides a component composed of a.html.htmlElement) and provides authoring tool that can refer to database when creating template and get its value and make WYSWYG (What you see is what you get) when constructing on screen.

That is, according to the present invention, the servlet has only Java code in order to completely separate the HTML document contents and the code of the corresponding language, and the HTML that was used in the previous method is stored as a template in the file system. If required by the servlet, the HTML processor transfers the template to the servlet (5,6). If data needs to be inserted into this template, the existing database system approach can be automated to Away from repetitive tasks, the automated function inserts database data into templates as templates (9,10).

1 illustrates a conventional servlet operation method. When a user makes a service request to a web server using a browser (1) through a web, the web server sends a service request to a web application server that runs a servlet according to the request. And (2) the servlet performs a database query and operation (4) and returns a result (6, 7, or 8). In this case, after all programs and operations related to operation and data manipulation, the screen requested by the user is made and turned. At this time, the screen (written in ML) is inherent in the servlet. In this case, the mix of screen sources and the sources that make up the business logic creates a lot of confusion for developers at development time. In addition, there is a lot of difficulty in the maintenance of the application (application), and the operation of the database has the inherent inconvenience that each must be newly created when necessary.

The method shown in FIG. 1 results in difficulty in production by using two different languages (java, html) mixed in servlet production, and also shows disadvantages in time and cost due to inconvenience in maintenance thereafter.

FIG. 2 is a schematic diagram of the Addra-WebCom configuration of the present invention, in which all items related to the database and CMDHtml (com.addra), which manages / calls all functions of the SQL processor 42 and the HTML processor 41, are inserted. SQL processor (42: com.addra.sql), a package that creates and manages a package connection pool that handles the creation, deletion, updating, selection, etc., processing HTML document contents, substituting table data with HTML contents, and user requests The component which consists of HTML processor 41: com.addra.html which is a package which processes the parameter related to (USER Request) is shown.

Figure 3 shows the operation of the present invention and the servlet has only Java code. The HTML that was used in the previous method is stored as a template in the file system, and the HTML processor sends the template to the servlet (5, 6) if necessary in the servlet. If you need to insert data into this template, you can automate the existing database system approach to get away from repetitive tasks in the SQL processor and use the automated function to insert database data into an HTML template as a template (9,10). .

4 is a package diagram showing the package structure of the present invention. It is divided into six packages, and it is functionally html package that manages HTML, sql package that manages database I / O, model package that handles data structure, htmlElement package that takes care of each component of html, and functional part. It consists of a util package and a servlet package that supports servlets.

5 is a class diagram that is a design of an html package for HTML.

6 is a class diagram of an sql package in charge of a database.

7 is a class diagram of a model which is data used internally.

FIG. 8 illustrates an example of creating a template using an authoring tool, by connecting a database to a template authoring tool, which is an HTML WYSIWYG editor, and importing a table in the database (FIG. 8A) into a template (FIG. 8B).

9 is a screen example (FIG. 9B) created when the template (FIG. 9A) created by the authoring tool is executed in a web browser which is a client.

When the web program is driven in the above manner, division of labor between the program developer and the screen designer at the time of production is possible, thereby improving readability by simplifying and clarifying the program source. In addition, even if the screen modification occurs later, only the template modification of the screen can be applied without recompilation or re-installation of the source, thereby bringing a lot of advantages in maintenance.

Table 1 is a table showing a web application development personnel deployment using the servlet of the present invention in comparison with the conventional method. In the following table in the present invention can be arranged to separate the personnel according to their respective roles.

Identifying team members based on MVC in developing web applications using servlets division View (designer) Controller (author) Model (Component Developer) Authoring (Webmaster) role Page layout Authoring flow Business logic Operating environment Existing use HTML / Servlet / JSP Database / Web Server / App.Server Use of the present invention HTML JSP Servlet Adra Webcom

As can be seen from Table 1, it is difficult to share the roles with existing uses in application development. Therefore, in the case of producing a large-scale solution, duplicate tasks are often repeated for each developer separately. The method is difficult to produce a program based on the MVC (model, view, control) methodology, but the present inventors Webcom has a ML (view) to handle the screen, a Java program (developers) to be developed by developers, and on the server Work can be maximized as it is divided into webcom (model) to handle data manipulation.

Hereinafter, the functional features of the component of the present invention will be described.

1. Separation of HTML (Presentation) and Servlet Code (Logic)

It is the biggest purpose of component development, and the biggest advantage is that it is easy to write and understand the program code, so it is easy to improve development productivity and maintain the future when constructing the system. Due to the separation of HTML and servlet code, modifications to HTML content can be applied without a separate compile or restart of the webserver.

2. Providing various components linked with database

Basic control (text, textarea, checkbox, radio, select, etc.) used in HTML form tag is interlocked with DB to enable input format / output format and simple (Data Validation Check) automatically.

3. Rapid development using (Visual Designer)

WYSIWYG (Wizwick) HTML editor works with the database to create a template for creating HTML document templates that can be integrated with ADLA-Webcom.

4. 100% pure Java based ensures excellent interoperability with other products

It is developed in 100% pure Java, so it can be easily integrated with other products that support Java such as JDK and JSDK, which are the most basic formats when writing servlet programs, and other web application servers. Can be.

5. Various template and wizard functions

Even beginners can easily write programs with various templates and wizard functions such as single input form and master-detail input form.

6. Easy connection with RDBMS

It has code internally to support various kinds of RDBMS (Oracle 7/8, Informix / Sybase / SQL-Server, etc.) and supports automatic processing of database (DB) related functions only if SQL is known.

7. Can use various data formats in templates

The format of the data to be output to the template makes it easy to create data in various formats.

8. External References to Floating Constants

By changing database information and English / Korean conversion problem fixedly into the source code from the source code and adjusting it externally, it is possible to replace the change of the environment variables of the server without changing the source.

In addition, the use environment of the present invention is as follows.

1. OS: all platforms (Java supported)

2. Web Server: Web Server + Servlet Server

Dev-Tools: Java JDK 1.1.6 or later / JDSK 2.0 or later

4. Database: All DBMSs that support JDBC, JDBC-ODBC

(Oracle 7.x (Or 8), Informix, Sybase, SQL Server, etc.)

5. Web browser: Netscape, IE (Internet Explorer), etc.

6. Client specification: Pentium or higher recommended (no OS limitation)

The present invention will be described in more detail with reference to the following examples.

Example 1 Writing the First Program Using the Present Invention

Assume that you have built a basic environment for writing servlets. This is a simple example program to show how the separation between the HTML document content and the servlet code mentioned above is done. There are two files to prepare. That is, .htm or .html file for HTML document content and .java file for servlet code part (HelloWorld.htm, HelloWorld.java).

First, write the HTML file, the part shown on the screen, as follows, and make a preview of how the final result will look.

[HelloWorld.htm]

The underlined part of the HTML code above is the part that will be replaced by the variable value later (Hello World !!, Addra-WebCom). Variable values will be explained later.

Every program developer has their own way of making a program and sticks to it. The recommendation mentioned here is not to change the way each program developer writes, but to provide a more convenient and faster way to write a program using Adra-Webcom.

The first is that if you want to create a servlet program with Adura-Webcom, always make the final output screen first.

In any case, the end result will be in HTML, which will be displayed on the screen by the browser. By checking the final results first, the final goal of writing the program is set, and how it is implemented internally.

Next, the variable values will be explained. First, let's modify the HelloWorld.htm file created above.

[HelloWorld.htm]

Hello World !! You can see that Addra-WebCom changed to <% NAME%> with <% CONTENT%>.

The reason for this change is to convert a variable declared as <% variable%> in the HTML document to a specific value in HelloWorld.java which will be created later. When you write a program using Addra-WebCom, you use variables of the form <% variable %%> in your HTML document.

These variables are later passed as parameters in the servlet code .Java file, which reads the values from ADLA-Webcom and replaces them in the HTML document. A variable can be a table column in a database or a specific part of HTML as above.

The HTML document part is complete and the servlet code part is written. Code as below and save as HelloWorld.java. Before compiling and running, the code looks like this:

01: import javax.servlet. *;

02: import javax.servlet.http. *;

03: import com.addra.html. *;

04: import java.io. *;

01 and 02 are basically things that need to be imported when writing servlets.

03 is the com.addra.html package of the three Adra-Webcom packages. Since the HelloWorld program has no database content, the com.addra.sql package is not imported. 04's java.io package is imported to use the PrintWriter.

06: public class HelloWorld extends BaseServlet

Class declaration. In the latter part, extends BaseServlet means to create a new class by extending BaseServlet. BaseServlet is a new class that extends from HttpServlet. .

08: String fileName;

09: AddraParameter params;

The string variable fileName used in 08 is used to specify which HTML file to load in the servlet later. Here it will be HelloWorld.htm. AddraParameter type variable of 09 params is a class type variable for specifying and passing values for variables defined in HTML document. Declarations are declared in the com.addra.html package, which interprets servlet parameters (HttpServletRequest, ServletRequest) and stores them in a hash table.

11: public void init (ServletConfig config) throws ServletException

12: {

13: super.init (config);

14:}

11 through 14 are the parts that initialize the servlet.

19: fileName = fileDir + "HelloWorld.htm";

Specify the HTML document for fileName. Where fileDir is specified in the BaseServlet.

21: PrintWriter out =

new PrintWriter (newOutputStreamWriter (res.getOutputStream ()));

22: setHeader (res);

21 is the part that declares and initializes the print (PrintWriter) for outputting the HTML content to the browser, and 22 is the part that specifies the Content Type in the hyperHttpServletResponse object.

24: params = cmd.getAddraPrameter (req);

25: params.put ("CONTENT", "Hello World !!");

26: params.put ("NAME", "Addra-WebCom");

From 24 to 26, the params variable is initialized and the parameter is assigned a value. You can see that CONTENT and NAME are variables defined in the HTML document. You can enter whatever you want for CONTENT and NAME.

28: out.println (cmd.showHtml (fileName, params));

cmd stands for CmdHtml Class (declared in BaseServlet). Passing HTML document and paramater through showHtml Method will read and replace variables in HTML and specified variable value.

30: out.flush ();

31: out.close ();

30 and 31 are the parts that empty and close the PrintWriter.

Now let's compile HelloWorld.java and see the result in the browser.

When the program is written using Addra-WebCom, the program shows how the separation between the HTML document contents and the Java Servlet Code is formed. This is a simple program now, but as the program grows in size and complexity, the effect of separating HTML document content from Java Servlet code will increase dramatically.

For example for the practice of the present invention as follows.

Let's change the HelloWorld.htm document we created in the program and save it. Save after modifying or adding the remaining parts except the variable part (document background color, text color change, font change, new content addition, etc.).

This is to find out what happens when the program is called again through a browser. In fact, if you call the program, you can see that modification and addition of HTML document contents are applied immediately without compiling Java Servlet Code or restarting web server.

This is possible because of the complete separation between the HTML document content and the Java Servlet Code.

Example 2 Writing a Second Program Using the Present Invention (Memo.java)

This time, let's write a program that works with Database.

Any DBMS can be used, and the program can be done only if all settings are added in addra.conf file according to the installation method.

First create a table in the database. Of course, you need to configure the table for your DBMS. For reference, we used Microsoft SQL Server 7.0.

Table name T schedule Column 1 M-Date Char (8) Column 2 M-Content Varchar (255)

Set column 1, M_Date, as the primary key. The program to make is a program that performs the following functions.

* You can enter a simple memo by date.

* You can search memo saved by date.

Like the first program, we first create the HTML document and save it as MemoEx.htm.

[MemoEx final result screen]

Pay close attention to the underscores in the HTML content. These parts have been added or modified to implement the functions in addition to the basic HTML document contents. Each part is described as follows.

function operSearch (form)

{

form.OPER.value = 'SEARCH';

form.submit ();

}

function operInsert (form)

{

form.OPER.value = 'INSERT';

form.submit ();

}

This part is a function of JavaScript. It is a function that executes a form and specifies parameters to be passed to the servlet when the query and input buttons are pressed.

<for mname = "form" method = "post" action = "http: // localhost / servlet / MemoEx">

The action of the form is specified. In other words, if you execute the form in a JavaScript function, you specify that the form executes the http: // localhost / servlet / MemoEx servlet. Note that the action value depends on your installation. Please specify the correct servlet location.

<input type = "hidden" name = "OPER" value = "">

If you specify the parameter (OPER) in JavaScript, the value will be specified.

<input type = "button" name = "search" value = "Query" onClick = "operSearch (this.form)">

When the Inquiry button is pressed, the relevant JavaScript is called.

<textarea name = "content" rows = "10" cols = "53"> <% M_CONTENT%> </ textarea>

When executing a query, the variable is declared where the contents of the memo will be displayed. This part will read the values from the database and replace them in the Java Servlet Code.

<input type = "button" name = "insert" value = "input" onClick = "operInsert (this.form)">

When the input button is pressed, the relevant JavaScript is called.

Now that you have the HTML document content, let's complete the Java Servlet Code.

Write it as below and save it as MemoEx.java.

Let's look at each part.

01: import javax.servlet. *;

02: import javax.servlet.http. *;

03: import java.io. *;

04: import com.addra.sql. *;

05: import com.addra.html. *;

The first part of the import section is the com.addra.sql package. This is because the second program deals with databases.

07: public class MemoEx extends BaseServlet

MemoEx Class declaration. Like the first one, we used an extension of the Base Servlet.

09: String fileName;

10: AddraParameter params;

11:

12: String [] paramNames = new String [] {"M_CONTENT", "DATE"};

13:

14: public void init (ServletConfig config) throws ServletException

15: {

16: super.init (config);

17:}

This is the part described in the first program. The variable fileName to specify the HTML document, params to specify the parameter value, params Names to define the parameter name to be accepted in request (M_CONTENT and DATE are used in the second program), and init function to initialize the servlet.

28: if (req.getParameter ("OPER") == null)

29: {

30: operStart (out);

31:}

32: else

33: {

34: String strOper = req.getParameter ("OPER");

35: String strDate = req.getParameter ("year") +

req.getParameter ("month") + req.getParameter ("day");

36: params.put ("DATE", strDate);

37:

38: if (strOper.equals ("INSERT"))

39: {

40: params.put ("M_CONTENT",

req.getParameter ("content"));

41: operInsert (out);

42:}

43: else if (strOper.equals ("SEARCH"))

44: {

45: operSearch (out);

46:}

47:}

The contents of 28 through 47 only display the HTML document on the screen when the first servlet is called.

It can be printed, but after that, it is written to handle the search function and input function separately according to the user's request.

If (req.getParameter ("OPER") == null), the first time the servlet is called, the OPER parameter passed in the request has no value. It checks this and writes only the HTML document contents. In the Else block, it is the case that the user inquires or inputs, so it reads all parameter values and checks the OPER among the request parameters to process the case of the inquiry and the case of the input separately. The request parameter OPER is passed a value in the JavaScript part of the HTML. The final functions called in each block are operStart (), operSearch (), and operInsert (). The details of these functions are described below.

52: public void operStart (PrintWriter out)

53: {

54: out.println (cmd.showHtml (fileName, params));

55:}

The operStart function called first. When the servlet is executed, only the contents of the HTML document are output first, so when the showHtml method is called, only fileName and params are passed.

57: public void operSearch (PrintWriter out)

58: {

59: String query1 = "select M_Content from TSchedule"

60: + "where M_Date = '" + params.get ("DATE") + "'";

61:

62: out.println (cmd.showHtml (fileName, params, query1));

63:}

OperSearch function to be called when the user selects a query. In this case, the query character to read data from the database is passed to the showHtml method. When the Query statement is passed, the data is read internally and replaced with the variable value defined in the HTML document content.

In this case, the variable <% M_CONTENT%> will be replaced with the database value.

65: public void operInsert (PrintWriter out)

66: {

67: String query2 = toKSC ("insert into TSchedule (M_Date, M_Content)"

68: + "values ('" + params.get ("DATE") + "', '" +

params.get ("M_CONTENT") + "')");

69:

70:

71: int ii = cmd.updateDB (query2);

72: if (ii == 1)

73: {

74: out.println ("registered");

75:}

76: else

77: {

78: out.println (query2);

79: out.println ("sql Error.");

80:}

81:}

OperInsert called when the user selects an input. Specifying the query statement to execute and passing the query statement to the updateDB () method executes the query statement and passes the result of executing the query statement.

The updateDB () method is divided into three types. It supports the execution of the general query statement used above, processing of PreparedStatement, and query execution as a String array so that the query can be executed multiple times.

So far, you have seen how to write servlet program with Addra-WebCom. As this is an embodiment, the glamor of the interface may be lowered or there may be a problem. If you go to the homepage, you can download many more various examples.

In order to overcome the shortcomings of the conventional servlet, the effect of the present invention is to separate the HTML document and the servlet program independently so that the web-based information system can be easily constructed, managed, and reused, and the maintenance of the program code is much easier. Significantly lowering the effect is also possible. In addition, distributed processing is possible by separating database linkage and presentation, and also overcomes the performance degradation caused by multiple user access.

Claims (3)

CMDHtml (com.addra), a package that manages / calls all functions of SQL processor 42 and HTML processor 41, and creates a package connection pool that handles inserting, deleting, updating, and selecting everything related to the database. And an HTML processor (42: com.addra.sql), which is a package to manage and processing HTML document contents, a function of replacing table data with HTML contents, and a parameter related to a request. Component consisting of (41: com.addra.html) In operating the component of claim 1, in order to completely separate the HTML document contents and the code of the corresponding language, the servlet has only Java code, and the HTML used in the previous method is templated in the file system. If the servlet requires it, the HTML processor transfers the template to the servlet (5, 6), and if data needs to be inserted into the template, it automatically automates the existing database system approach to the SQL processor. How to operate a component, characterized by inserting database data as a template (9,10) into an HTML template with an automated function away from the repetitive tasks in In order to completely separate the HTML document contents and the code of the language for the component operation of the claim 1, the servlet has only Java code, and the HTML used in the previous method is stored as a template in the file system. The HTML processor transfers the template to the servlet (5,6) if needed by the servlet, and if the data needs to be inserted into the template, the existing database system approach can be automated to Component program, characterized by inserting database data as a template (9,10) into an HTML template with an automated function away from the repetitive task of