KR20060079690A - Component-based programming automation process using templates and patterns - Google Patents

Abstract

 The present invention relates to a method for automating component-based programming using a template and a pattern. The present invention relates to a standard screen configuration, common script, component information to be referred to, image file, and standard directory configuration, which are components of a program, as templates. (A) generating and managing a program code pattern which can be repeated and reused in a management step and a programming process in advance; (B) automatically constructing a project of a program to be created using the template provided in step (a); (C) setting an execution environment of the project generated in the step (b); (D) automatically generating a component class for processing a program screen and a business logic using the template provided in the step (a); (E) a data binding step of linking tables and fields of a database previously constructed to store data processed by a program with controls on a program screen and setting properties of the data; (F) creating a conformance check expression for automating a conformity check on data input by a user on a program screen; (G) automatically generating necessary code by applying the program pattern generated in the step (a) to the program screen and the business logic component class generated in the step (d); (H) adding and writing a program code to the step (g); By connecting the completed program screen and the work logic component through the above step (ah), the data input from the program screen is collected, transferred to the work logic component as parameters, and the processed results are returned to the program screen. It characterized in that it comprises a step (i) showing.

 According to the method of the present invention, the use of templates and patterns simplifies the development process, provides convenience of development work, reduces the development time of the program by an automated coding method, and uses the present invention even for beginners with little development experience. You can easily develop the program you want, and well-designed templates and patterns improve the quality of the program and allow you to develop stable and robust programs.

Program, Automation, Component, Pattern, Template, Data Binding, Conformance Check, Auto Generation, Class, Object

Description

 Component-Based Programming Automation Process using Templates and Patterns}

 1 is an overall flowchart of a program creation automation method according to a preferred embodiment of the present invention.

 2 is a flowchart of a template management step according to a preferred embodiment of the present invention.

 2A is an exemplary diagram of a template management screen according to a preferred embodiment of the present invention.

 2B is an exemplary view of a template editing screen according to a preferred embodiment of the present invention.

 3 is a flowchart of a pattern management step according to a preferred embodiment of the present invention.

 3A is an exemplary view of a pattern management screen according to a preferred embodiment of the present invention.

 3B is an exemplary view of a pattern editing screen according to a preferred embodiment of the present invention.

 Figure 3c is an illustration of a screen for automatically generating a source code using a pattern according to a preferred embodiment of the present invention

 4 is a flowchart of an execution environment setting step according to a preferred embodiment of the present invention.

 4A is an exemplary diagram of an execution environment setting screen according to a preferred embodiment of the present invention.

 5 is a flowchart of a data binding step according to a preferred embodiment of the present invention.

 5A is an exemplary diagram of a data binding screen for a program screen according to a preferred embodiment of the present invention.

 5B is an exemplary diagram of a data binding screen for a multi-grid control according to a preferred embodiment of the present invention.

 Figure 6 is a flow chart of the conformance check formula setting step according to a preferred embodiment of the present invention

 Figure 6a is an illustration of a conformance test formula setting screen according to a preferred embodiment of the present invention

 Figure 7 illustrates the type and relationship of the business logic component class according to an embodiment of the present invention

 8 is an exemplary diagram of a screen for automatically generating an entity class according to an embodiment of the present invention.

 The present invention relates to a method for automating component-based programming using a template and a pattern. More specifically, when a user selects a desired template by providing a template in advance, the project of the application is automatically configured using the template configuration information. It automatically generates the program standard screen composition and source code of business logic component class, and connects the tables and fields of the pre-built database with the control of the program screen to set data properties. Set the conformance check formula to automate the input control and display of the program, and the conformity check of the data entered on the program screen, and provide the program code pattern in advance to use the configuration information of the selected pattern. By pro Ram source code relates to a method that will be generated automatically.

 The current information technology has developed a lot. In particular, the structure of the program has changed a lot. In a monolithic program that implements all functions in one program, a library-oriented program that implements a program by modularizing common functions into a library. An object that develops function encapsulation logic and related data into classes. As an object oriented program, a component-based program that separates a collection of classes into executable independent components and has developed into a distributed component program method in which components are distributed to a server and connected to each other. The ultimate direction of the development of information technology is to improve the productivity of software development through reuse and automation and to facilitate the organic integration among distributed systems based on standardized technology (H / W, It is to reduce the total cost of ownership (TCO) of S / W). However, as the structure of information technology becomes more complicated, the risk factors and performance deterioration factors of the technology structure increase, so it is necessary to identify the problem factors in advance and set the method and scope of application of the technology structure. Simplified and standardized, application tasks are larger and more complex than ever before, and the methods of analysis and design become important. Due to this complex situation, development productivity is never improved compared to the past, and the quality of the developed software is not improved. This is illustrated by statistics published by the Standish Group in the United States. Statistics show that only 16% of all software development projects were successful, 31% failed, and the remaining 53% were delayed or costly. This means that different results are produced depending on how the technology is applied rather than the problem of information technology itself.

 The conventional program development method is to document the guidelines for the development standard and educate the developer so that the developer writes the components of the program according to the development standard guidelines document to compose the application project, compose the program screen, and work logic component. To create a class. Although some tools currently provide templates, the templates are fixed and cannot be added to the development work because new templates can be added / modified and distributed to each developer. In addition, coding and control of the data and input of the program screen are implemented by coding by connecting the tables and fields of the pre-built database to the control of the program screen. .

 However, the above-described conventional method is large and the size of the software is gradually increased, and many developers are involved in the development of the situation in which the work is carried out through collaboration with each other, and the program development requires a lot of experience and the ability of each individual. As a result, there is a tendency that the individual dependence on the result is largely prevented the efficient software development. First of all, the template cannot be applied to development work because it cannot freely add / modify the template and can be distributed among developers, and the development standard guideline provided in the document is the standard for development due to the difference of developer's understanding. It can't be guaranteed to be consistent, and even the same function can be coded differently according to the developer's ability, the performance of the program can be different, and simple and repetitive tasks are still going on. . In addition, the style of writing code during development and maintenance is almost the same as that of re-development because of the different relationship between developers. This problem leads to a reduction in development productivity and software quality, resulting in a loss of total cost of ownership (TCO).

An object of the present invention is to solve the above-mentioned problems of the prior art, and provides the user with a template in advance by providing a standard screen configuration, common script, component information to be referred to, image file, standard directory configuration, etc. If you select the template you want, you can use the template configuration information to automatically configure the application project, automatically configure the program standard screen and generate the source code of the business logic component class, and display the table and fields of the pre-built database. Data binding, which connects with the control of the data and sets the properties of the data, automates the input control and representation of the data, sets the conformance check expression to automate the conformity check of the data entered on the program screen, and sets the program code pattern. Provided in advance for use Will increase productivity by selecting the desired pattern reduces errors by standardizing programming by providing a method of automatically generating a program source code, using the configuration information of the selected pattern ensures the quality and simplicity.

 The present invention for achieving the object as described above, relates to a method for automating component-based programming using a template and a pattern, the standard screen configuration, common script, component information to be referred to, image, the components of the program Generating and managing a file, a standard directory structure, and the like as a template in advance and generating and managing a program code pattern that can be repeated and reused in a programming process in advance; Automatically constructing a project of a program to be created using the template provided in step (a) (b) setting an execution environment of the project created in step (b) (c) template provided in step (a) (D) Automatically create a component class that processes the program screen and business logic by using (d) Connect the table and fields of the database that has been built in advance to store the data processed by the program with the control of the program screen and (E) creating a conformance check expression for automating conformance check on the data entered by the user on the program screen (f) program screen and work logic component class generated in step (d) Apply the program pattern generated in step (a) to automatically generate the necessary code Step (g) adding the program code to the step (g) to create (h) connecting the program screen and the work logic components completed through the step (ah) to collect the data input from the program screen It is characterized in that it comprises the step (i) to pass to the business logic component as a parameter to process and return the processed result back to the program screen to show the result.

 Hereinafter, with reference to the accompanying drawings will be described in more detail the present invention.

 1 shows an overall flow diagram of a programming automation method according to a preferred embodiment of the present invention. As shown in FIG. 1, first, a new template and pattern is generated according to standard guidelines required for development, or an existing template and pattern is modified and managed in a repository (11).

 2 is a flowchart illustrating a method of managing a template by creating or modifying the template. Here, the template refers to the arrangement and structure of the elements necessary to compose the application, and more specifically, includes the program screen configuration, common scripts, component information to refer to, image file, standard directory configuration, component class configuration, and the like. I mean. 2A illustrates an example of providing a user with a function of creating and managing a template. As shown in Fig. 2A, the user is provided with an overview of the function of classifying and editing a template. The currently registered templates are displayed as a list classified for easy management by users (21), and templates are largely classified into project template for deploying and structuring an application and project configuration item templates for placing and structuring each component. It is preferable to classify these again according to languages such as VB, C #, C ++, and Java, and then classify them again according to program functions (22). The classification of templates can be freely classified according to the user's needs. Project templates include templates for creating web applications, templates for creating windows-based applications, templates for creating Java-based applications, templates for creating batch programs, and daemon programs. It is preferable to classify it into a template for creating a function, a class library template for creating a business function component, etc. The project configuration item template includes a screen template for single record processing, a screen template for multi-record processing, and a master of 1: N relationship. Screen templates for detail processing, screen templates for pop-up processing, screen templates for file upload and download processing, screen templates for N: N relationship data processing, screen templates for graph processing, and business function components. It is preferably classified as class templates. Edit the configuration (23) and edit the required component file (24) to place and structure the classified template. 2B illustrates an example of providing a user with an editing function for placing and structuring a template. As shown in FIG. 2B, the template is composed of a wizard script and component files for automatic placement when the template is selected by the user, and is preferably managed separately in a separate directory for each language for multilingual support. The structure of the template means the organization of the directory and can be changed by the user as needed. Component files contain program code that conforms to the standard guidelines. The newly created or modified template can be saved by the user (25). If it is a project template according to the classification of the template (26) it is stored in the project template repository (27) or otherwise stored in the project template configuration item repository (28). In addition, in order to show the list of templates in the step 21, it is preferable to store information such as a template ID, a template name, a template description, a template location, a project name or a basic file name of a configuration file when the template is generated. Provides the ability to create a distribution file to share newly created or modified templates with all developers (29), and the distribution scope allows users to select all or part of the template and to distribute a single template to facilitate deployment. It is preferable to generate a compressed file, and distributed template compressed files need to be installed by each user on their own computer. The template created above simplifies the programming process by automatically constructing the structure of the application using the project template and automatically generating and adding program components using the required project configuration item template. You can.

 3 is a flowchart illustrating a method of creating or modifying and managing a pattern. Here, the pattern means a part of program code that is used repeatedly, and more specifically, it can pattern everything represented by text including a coding style and actual program code. The registered patterns are displayed as a list classified for easy management by the user (31), a pattern editing operation (31a) for registering or modifying a new pattern, and an operation for automatically generating the registered pattern for use in programming (31b). And distribute the registered pattern to all developers to share it (31c). 3A illustrates an example of providing a user with a function of registering, modifying, and managing a new pattern. As shown in Fig. 3A, the user is provided with an overview of the function of classifying and editing patterns. Patterns are largely categorized by language applied to programming such as VB, C #, J #, C ++, JAVA, DBMS, WEB, etc., and they are classified into fixed patterns that are provided as standard and custom patterns that can be defined and used by project or user unit. Then, it is desirable to sub-classify each program function such as storing, deleting, inquiring, and event processing (32a). The classification of patterns can be freely classified according to the needs of the user. The classified pattern data can be edited (33a), and the change factors are inputted from the user when the pattern is automatically generated by applying the change factors according to the usage environment of the pattern. It provides a function to apply a regular expression (34a) to a pattern so as to generate a pattern. Regular expressions of patterns are not essential to using patterns all the time, but are essential elements for implementing a wizard function that allows the content of a pattern to be changed according to a developer's choice. FIG. 3B illustrates an example of providing the user with the functions of steps 33a and 34a. As shown in FIG. 3B, an ID for identifying a pattern, a description of the pattern, and a change element of the pattern are represented. Consists of regular expression and pattern data for regular expression, and pattern regular expression is represented by regular expression ID to distinguish regular expression and wizard during automatic generation. It consists of the description of regular expressions and the default values for regular expressions. The default value for Regular Expression is the default value of Regular Expression that is input from Wizard when pattern is automatically generated and is required to minimize the input from the user. The wizard that automatically generates the pattern generates the final pattern data by changing the regular expression of the pattern into a regular expression value input from the user. The newly registered or modified pattern may be stored by the user (35a). In order to show the list of patterns in the pattern storage 37, the configuration information including the pattern data to which the regular expression is applied and the pattern regular expression information is stored in the pattern storage 37, and the pattern ID and the pattern It is preferable to store information such as description and pattern classification in a separate pattern catalog storage 38. The pattern catalog repository is also used as an index to search for patterns. FIG. 3C shows an example of providing a user with the functionality of providing a task 31b for automatically generating a registered pattern for use in programming. As shown in FIG. 3C, the user is provided with an overview of the wizard function for automatically generating a pattern. When the user selects one or more desired patterns (32b) from the list of registered patterns displayed in step 31 above, a description of the pattern regular expression is performed using the configuration information of the pattern selected in the pattern storage 37. Display and pattern regular expression values for user input (33b), users enter values for pattern regular expressions (34b), and wizards for automatic pattern generation ) Converts a regular expression set in the pattern data into a regular expression value input by the user in step 34b to generate a desired final pattern (35b), and the generated pattern is generated by the user. Automatic copy to program location (36b). Provides the ability to create a distribution file to share newly registered or modified patterns with all developers (31c), and the distribution scope can be selected by the user in full or partial pattern. It is preferable that the file is generated by compressing the file, and the distributed pattern compressed file needs to be separately installed by each user on their own computer. As described above, working with patterns makes it possible to simplify the repetitive tasks of programming and maintain a consistent programming style.

 After generating a template and a pattern necessary for program development in advance and providing it to a developer, a task of automatically constructing a project of a program to be created using the provided template is performed (12). The wizard registered in the template automatically creates a project with the same structure as the template using the template's configuration information. After configuring the project, we set up the environment for program execution (13). 4 is a flowchart illustrating a method of setting an execution environment of a program, and FIG. 4A illustrates an example of providing a user with a function of setting an execution environment. As shown in FIG. 4A, execution environment information is shown. The project ID to identify the project, the type of database to use, the method to access the database, the connection string, the company name to use the program, the data source information for the database connection, whether to set the program to developer mode or service mode, You can manage strings as text or in separate executables to hide them. The execution environment information is displayed on the screen so that the developer can easily manage it (41), so that the user can connect it (42), and the set environment information is stored in an XML form in a separate environment information repository 45. It is preferable to store 43 as. The configured environment information is used to process data by accessing the database from the business function component, and the information is preferably stored in XML so that it can be easily managed and accessed by the program.

 After setting the execution environment for the program, a task of automatically generating a program screen to be created using a template provided in advance is performed (14). If the user selects a template suitable for the screen type of the program, the wizard registered in the template is automatically added to the project with the same structure as the template, and the added program screen needs to be separately edited and completed according to the purpose. .

 After creating a program screen using a template, data binding is performed by linking the tables and fields of the pre-built database with the controls of the program screen and setting the data properties to store data processed by the program screen. 15).

 5 shows a flowchart of a method of binding data. 5A illustrates an example of providing a user with the ability to set up data binding. As shown in Fig. 5A, the user is provided with an overview showing the function of supporting the operation of linking the fields and the tables of the pre-established database to all the objects represented on the program screen. Data binding works on all objects represented on the program screen individually, so that all objects represented on the program screen are listed and displayed (51), and tables in the database (57) to be connected to the screen objects to facilitate the user's binding. The list and field information for each table are displayed to facilitate binding by the user (52). Information necessary to access the database is accessed using the execution environment information set in step 13 above. The binding information to be set in the screen object includes the ID of the object, the name of the object, the title of the object, the length of the data displayed in the object, and the data source ID necessary to structure and store the object value in an XML format in the screen buffer. The data field representing the column D to be displayed, the type of data displayed on the object, the predefined style sheet information to set the type and color displayed on the screen, and the binding information for the table in the database include the table ID and the table. The name and the like are included. The binding information for the field of the database includes the column ID, the column name, and the data type of the column. The data binding task is to connect the columns of the table to the objects on the screen individually. The object ID and the object name are set by prefixing the column ID with a predefined prefix for each data type. The object title is set as the column name. The object data length is set to the data length defined in the data type of the column, the object data field is connected by the column ID, and the object data type is connected by the data type of the column. The types of objects represented on the screen may be classified into objects represented by a single text and objects represented by a grid. Objects represented by a single text can be data-bound in the same manner as described above, but grid-type objects are preferably bound by grid cells. 5B illustrates an example of providing a user with a function of data binding a grid object. As shown in FIG. 5B, the user is provided with an overview of a function of supporting the operation of linking a table and a field of a pre-established database in units of cells to a grid object represented on a program screen. Is handled in the same way as the object represented by the above single text. The size, position, color, shape, Korean-English, mandatory input, etc. of the screen object, which are not set by the binding, are set separately by the user.The object data source ID is selected by the user by selecting a data source object represented on the screen. Additional work is required (54). If the created data binding information is managed in a separate repository rather than a program screen file, management problems will occur. Therefore, create a data container object 58 for storing information on the program screen, and store the data binding information in an attribute of the data container object (56). (55) to store the same file as the program screen file. Data binding allows the user to automatically control or express numbers, characters, formatted forms, whether they can be input, and whether it is Korean or English.

 After the data binding is set, a conformance check expression is set to automate checking whether data entered on the program screen is correctly input (16). 6 is a flowchart illustrating a method of setting a conformance check equation. FIG. 6A illustrates an example of providing a user with a function of setting a conformance check expression, and as shown in FIG. 6A, a function of supporting a task of setting a conformance check expression for all objects represented on a program screen. An overview is provided to the user. The conformance check setup works on all objects represented on the program screen individually, so that all objects represented on the program screen are listed hierarchically so as to make it easier for the user to perform the conformance check setup (61). Adds a new test equation and selects a desired test equation from the predefined conformance test equation type (62). The conformity check expression type includes the data change check expression for checking whether the data has been changed when saving the data of the program screen, the required input check expression for checking the input for the required input items among the objects on the program screen, and the data value. Comparison check expression that compares the size (=,>, <, <>,> =, <=), range check expression to check the range of data values, and compares data values with values by regular expressions It is preferable to classify the expression into a regular expression for checking, and a user-defined check expression for calling and checking a function written by a user. Information to be set in the inspection formula selected in step 62 should be provided so as to be easy to set by the user (63). The information to be set for each inspection formula is different from each other.In the data change inspection formula, the ID of the data source object and the grid object expressed on the program screen can be set to check whether the internal data of the object has changed. There is no information to set separately because the input check expression is checked by using the required input information set in the data binding step. The comparison check expression sets one of the comparison operators =,>, <, <>,> =, <=. To set the comparison value, the range check expression sets the minimum and maximum values and sets the comparison operator to set the range of values. For the check expression by regular expression, the calculation expression and the comparison operator you want Set the function name and set the function name to call the user-written test function. (64). In addition, information to be set common to all test expressions includes error message contents, color of error message, object to display message, and error message by test expression unit as expression method of error message to be displayed when conformance error occurs. There is information such as whether to display or to express the entire error message that occurred and to express it as one message. If the conformity check expression information created in step 64 is managed in a separate storage rather than a screen file, a problem arises in management, so a data container object 67 for storing information on a program screen is created and inspected in the attributes of the data container object. Expression information is stored 66 so that it is stored in the same file as the program screen file (65). The conformity check formula can automatically check the conformity of the data entered into the program screen without any coding.

 After the program screen is created using the template by the above steps (14, 15, and 16), a task of generating a component to create a business logic using a template provided in advance is performed (17). If the user selects a template suitable for the component type, the wizard registered in the template is automatically added to the project with the same structure as the template, and the added component class needs to be separately edited and completed according to the purpose. Depending on the size of the project, the number of components is quite large, and the number of classes is quite large because the components are collections of classes. Current distributed component technology is a form of serving one component to a large number of users, so how the component configuration has a significant impact on the stability and performance of the system, and in particular, how to classify and organize a large number of component classes. This is an important decision.

 7 illustrates types of component classes and relationships with each other. As shown in FIG. 7, the component class is preferably classified into a control object 71, an entity object 72, a business object 73, and a data access object 74. The control object is the first class called in the program screen. It is a class that processes data depending on the program screen. It exists in the unit of program surface and business logic starts from this class. An entity object is a class that implements logic that processes data in a table in a database. The data input from the program screen is passed to the control object, which is then passed back to the entity object, and the entity object automatically generates an SQL statement for processing data in the database using data binding information included in the passed data. Process the data. Business objects are classes that implement common business logic. They are called and used by a number of control objects, and processing for the database is handled through entity objects. A data access object is a class that accesses a database and processes SQL statements. It can be called by all the above objects. Such classifications and relationships are important factors to increase the reusability, stability, scalability, and maintainability of components. Because entity objects are formalized in the way they are handled, it is desirable to allow them to be created automatically by automated tools. FIG. 8 illustrates an example of providing a user with a function of automatically generating an entity class, and as shown in FIG. 8, automatically generating an entity class in table units for all tables registered in a database. An overview of the functions supported is provided to the user.

 After the program screen and the work logic component are created using the template by the above steps (14, 17), a detailed program is created using the previously provided pattern (18). The method of automating the programming by applying the pattern is the same as the pattern generation operation described in step 31b.

 After applying the coding pattern to the program, it is necessary to separately complete the program by adding and modifying the program in detail and connecting the program screen and the work logic component (19).

 According to the method of the present invention, the use of templates and patterns simplifies the development process, provides convenience of development work, reduces the development time of the program by an automated coding method, and uses the present invention even for beginners with little development experience. You can easily develop the program you want, and well-designed templates and patterns improve the quality of the software and allow you to develop stable and robust software. In addition, it can ensure that the development is consistent with the standard guidelines, and the problem of the result being changed according to the individual's ability can be solved.Effective development is achieved by eliminating simple repetitive programming tasks through programming automation. Even after development, the style of writing code is not different among developers, making maintenance easier. Ultimately, total cost of ownership for the software

It has the effect of reducing TCO.

Claims (7)

 A method of automating programming, comprising the steps of pre-generating program components into a template, pre-generating reusable program code patterns, automatically constructing a project of a program to be created from the generated template, and executing the configured program. Environment setting step, automatic generation of component class using generated template, data binding step for storing data processed by program, automatic generation of code by applying generated program pattern to component class How to automate component-based programming with featured templates and patterns.  The method of claim 1, wherein the method of automating component-based programming using a template and a pattern comprises a step of setting a check expression for checking suitability of input data after data binding in a data binding step.  The method of claim 1, further comprising: adding and writing new program code in the step of automatically generating code by applying the generated program pattern to the component class.  The method of claim 1, wherein the components are connected to each other to collect input data, pass them as parameters to the work logic component, process them, and display the processing result on a program screen. .  The method of claim 2, further comprising: adding and writing new program code in the step of automatically generating code by applying the generated program pattern to the component class.  The method of claim 2, wherein the components are connected to each other to collect input data, pass them as parameters to the work logic component, and process and display the processing results on a program screen.  4. The method of claim 3, wherein the components are connected to each other to collect input data, pass them as parameters to the work logic component, process them, and display the processing result on a program screen.

Images