CN115562642A - Code generating method based on database and Mustache template engine - Google Patents

Abstract

The invention discloses a code generation method based on a database and a Mustache template engine, including four functional modules: a database data reading module, a template file creation module, a Mustache template engine parsing module and a file output module. The invention is not only applicable to system engineering design , related to the use of database storage information, the specified template for data content generation can be output as a valid file; the advantage of this method for the project structure is that the generated code does not change the project structure, and for developers, it reduces manual spelling errors and Higher working pressure reduces the problems that may often occur in the testing work, greatly shortens the software development cycle and improves product competitiveness.

Description

Method of generating code based on database and Mustache template engine

technical field

The invention relates to the field of IT data development, in particular to a code generation method based on a database and a Mustache template engine.

Background technique

With the rapid development of science and technology and the increasing pace of social life, users are more demanding and demanding of commonly used software, which prompts companies to continuously update and iterate products to optimize user experience.

During the project development process, business personnel spend most of their time re-editing similar content repeatedly from database design, interface design, service design, data layer design, and object entity class design when developing business logic code. Lots of repetition and complicated processes.

At present, there are several generation tools on the market, but they are often aimed at specific architectures and specific scenarios to automatically generate corresponding codes. There is no method for automatically generating code files for the development of the entire front-end and back-end process codes. In order to better The solution applies to the method or system for automatically generating code files based on the public project architecture, and the innovation and expansion of code generation methods become particularly important.

Frequent iterations, fast version presentation, and increasing pressure on project team development members. The above-mentioned method of the prior art requires a large workload of developers and a long time for the version to go online. Therefore, an efficient method and system for generating code files, It is of great significance in the project development process.

Contents of the invention

The technical problem to be solved by the present invention is to overcome the defects of the prior art and provide a code generation method based on database and Mustache template engine.

The present invention provides following technical scheme:

The present invention provides the generation code method based on database and Mustache template engine, comprises database data reading module, template file creation module, Mustache template engine parsing module and file output module four functional modules, comprises the following steps:

S1. The user creates the required database table structure information in advance according to the business needs;

S2. Create a template code file for the requirements according to the project structure, including the database persistence layer related mapping code template mapper.xml involved in the backend, the persistence layer processing code template mapper.java, the entity class BO code template entity.java, and the business logic layer Processing code template service.java, and the page files involved in the front end include but are not limited to html, vue, js and other front-end page code files;

S3. Read the configuration file through JdbcTemplate and connect to the database to read the table structure information and store it in the data structure;

S4. Generate the required code by parsing and replacing the template content through the Mustache template engine, and output the generated code to the corresponding path;

S5. Compile, run and publish the created and updated code to the server.

As a preferred technical solution of the present invention, the database described in step S1 is not limited to commonly used databases such as mysql, oracle, pgsql, etc., and the database table structure is designed with corresponding fields according to business requirements.

As a preferred technical solution of the present invention, the template solution described in step S2 is not limited to any framework, and generates the required project code files according to its own project requirements and project structure, including:

S2.1: Design and creation of persistence layer-related code templates in the project structure. The template name mapper.xml mainly includes related requirements methods such as xml constraints, corresponding additions, deletions, modifications, and queries. The required table names and fields use "{{XXX}}" Replacement; the template name mapper.java is a Class object structure containing methods corresponding to mapper.xml, and the imported Jar package structure and related BO content are replaced with "{{XXX}}";

S2.2: In the project structure, the business logic layer handles the design and creation of code templates. The template service.java is a Class object structure containing the corresponding methods for external interface calls, corresponding input and output parameters, and template strings for entity DTO "{{ XXX}}" replace;

S2.3: Design and creation of the entity class code template in the project structure, the template entity.java entity class BO code file corresponds to the database table structure fields one by one through {{/idColumn}}, {{^idColumn}} cycle;

S2.4: Design and creation of the front-end file template in the project structure, the page template file default.html or page.vue uses "{{XXX}}" to replace the field content in <div>, and the front-end logic JS file api.js "{{firstUp}}" etc. to replace relevant content.

As a preferred technical solution of the present invention, step S3 describes reading the configuration file through the JdbcTemplate to connect to the database and read the table structure information. The JdbcTemplate encapsulates the JDBC database interactive operation, and it mainly encapsulates the JDBC loading driver to create the database DataSource data source. DriverManagerDataSource, inject JDBC driver step to inject DriverClassName into the DriverManagerDataSource property; including the following:

S3.1: Create a JdbcTemplate object through the new JdbcTemplate() method, and pass in the designed connection pool information including the table name information designed in step S1 and the link address of the database: "jdbc:mysql://127.0.0.1:3360/ xxx?useUnicode=true&characterEncoding=UTF-8" and so on;

S3.2: Prepare the query table structure information statement "SELECT column_name`name`,column_comment`label`,data_type`type`,COLUMN_KEY`key`,EXTRA FROMinformation_schema.columnsWHERE table_name=‘XXX’and table_schema=‘XXX’”;

S3.3: Use the existing JdbcTemplate object to execute the query statement database operation through the query method, and query the detailed information of the table structure according to the table constraints, including the list of fields in the business table, including column names, detailed descriptions, physical types, Java types, and Java properties The name, primary key, etc. are stored in the related storage List collection list to prepare for the use of the subsequent step S4.

As a preferred technical solution of the present invention, the core of the Mustache template engine described in S4 is to replace the tag content in the template file described in S2 with the data content of the data table stored in the data structure; its idea is to convert the template into tokens In the nested array, combine tokens and data to generate strings, and then split them according to different types and package them into arrays. The stored strings correspond to Mustache engine identification information. The detailed steps are as follows:

S4.1: Disassemble the template string and classify it; when choosing to generate code, the program will read the templates created in S2 in order, and the place where the key variable is used in the template string or the traversal or if judgment is used must be Columns wrapped with "{{" and "}}" are like a string of template strings: "<ul>{{#name}}<li><dl><dt>{{#age}}{{#hobbys} }<dd>{{.}}</dd>{{/hobbys}}</dt></dl></li></ul>", ordinary strings are on the left side of "{{", Therefore, you can find the normal string by looking for the position of "{{", and then intercept; find the position of "}}", and then intercept the cycle until there is no string to intercept, so the template string becomes "" <ul>{{","xxx" and "}}<li>...";

S4.2: Convert the string template into an array of tokens; the scanner receives the template content as its construction parameter, relying on the two scanner methods scan and scanUntil inside Mustache, the function of the scan method is to make the pointer skip the specified token, and the scanUtil method The function is to traverse one character at a time to find the specified token; loop recursively into the tokens array, get the string before the start delimiter, store the string as "text" in the tokens array, skip the start delimiter, get the start delimiter and the end The string between delimiters, if the starting character is "#", store the string as "#" in the tokens array, if the starting character is "/", store the string as "/" in the tokens array, Skip the end delimiter, get the tiled and grouped string array and return the string tokens array;

S4.3: Assemble the tokens array by grouping; use the tokens string array returned by S4.2 using the idea of data structure stack (FIFO/LIFO) to push the stack when it encounters a "#" character, and to exit when it encounters a "/" character The stack, the content between the "#" character and the "/" character is its sub-element; when the "#" character is encountered, the current token (token is a single string attribute after the tokens cycle) is pushed into the stack array, And set the result collector as a subset of the tokens that just entered the heap, and remove the latest one in the stack array when the "/" character is encountered, and set the result collector as the token that is at the top of the stack in the stack array Subset, or the final structure set, if it is not a "#", "/" character, directly add the current token into the result set, and return the assembled tokens result set array;

S4.4: Render template strings into code files according to tokens; loop tokens, "text" characters match ordinary strings, and directly concatenate them; if it is "name" characters, child and parent object attributes access object attributes using the existing lookup method The role is to dynamically access the deep attributes on the object in the form of strings to obtain the parsed string splicing processing. If it is the "#" character, parse the loop in the tokens string template to generate a good string and then splicing processing, and finally The spliced string is the rendered code file.

As a kind of preferred technical scheme of the present invention, step S5 is through FileUtils file output tool class write character string to file, the character string that the mustache template engine parsing module has resolved generates corresponding code file, compiles project deployment to server.

Compared with the prior art, the beneficial effects of the present invention are as follows:

1. The corresponding code files can be automatically generated without targeting a specific architecture;

2. The front-end code and back-end code can be generated through the analysis of the Mustache template engine, and the file type has no limitation;

3. Automatically deploy to the path address, realize one-click and intelligent code release, simplify deployment and improve efficiency;

4. The code generation method of this solution is a separate method, which does not require additional tools such as Jar packages in the project; it is different from the common code generation methods in the market that integrate with projects and introduce other external Jar packages. Complete decoupling, no mutual influence and no impact on the original structure;

5. This method is not only applicable to system engineering design, but also can generate a specified template for data content and output it into a valid file related to the use of database storage information; the advantage of this method for project structure is that the generated code does not change the project structure, and it is beneficial to developers In terms of reducing manual spelling errors and greater work pressure of developers, reducing possible frequent problems in testing work, greatly shortening the software development cycle, and improving product competitiveness.

Description of drawings

The accompanying drawings are used to provide a further understanding of the present invention, and constitute a part of the description, and are used together with the embodiments of the present invention to explain the present invention, and do not constitute a limitation to the present invention. In the attached picture:

Fig. 1 is a work flow chart of the present invention;

Fig. 2 is the display diagram of configuration database table structure information page of the present invention;

Fig. 3 is a flow chart of the overall structure of the present invention.

detailed description

The preferred embodiments of the present invention will be described below in conjunction with the accompanying drawings. It should be understood that the preferred embodiments described here are only used to illustrate and explain the present invention, and are not intended to limit the present invention. The same reference numerals in the drawings all refer to the same components.

Example 1

As shown in Fig. 1-3, the method and system for automatically generating code files based on database tables in the present invention, the method is suitable for the development of commonly used front-end and back-end code frameworks, as shown in Fig. 3, including the following steps:

S1: The user creates the required database business table structure information in advance according to the business needs; the database is not limited to Mysql, Oracle, Pgsql, etc. This example uses the Mysql database.

S2: Design a code template scheme for the business table according to the project structure, including the database persistence layer-related mapping code template mapper.xml involved in the backend, the persistence layer processing code template mapper.java, and the entity class BO code template entity.java, dto. Java, business logic layer processing code template service.java, serviceImpl.java, and the page files involved in the front end include but are not limited to the front-end form page display code template default.html, page.vue, page logic code template api.js and other front-end Page code file.

S2.1: Design and creation of persistence layer-related code templates in the project structure. The template name mapper.xml mainly includes related requirements methods such as xml constraints, corresponding additions, deletions, modifications, and queries. The required table names use "{{tableName}}" and return Values are replaced by fields such as "{{firstUp}}"; the template name mapper.java is a Class object structure containing methods corresponding to mapper.xml, and the imported Jar package structure and related BO content are replaced by "{{firstDown}}" ;

S2.2: In the project structure, the business logic layer handles the design and creation of code templates. The template service.java is a Class object structure containing the corresponding methods for external interface calls, corresponding input and output parameters, and template strings for entity DTO "{{ firstUp}}", "{{firstDown}}" fill;

S2.3: Design and creation of the entity class code template in the project structure, the template entity.java entity class BO code file passes through the code module

"{{/idColumn}}{{^idColumn}}

private{{javaType}}{{prop}};

{{/idColumn}}{{/columns}}";

Loop out the fields corresponding to the database table structure one by one;

S2.4: The design and creation of the front-end file template in the project structure, the page template file default.html or page.vue replaces the variable value in the table with "{{prop}}". For example, an "input" label: "<inputclass="form-control input-sm"id="update_{{prop}}"name="{{prop}}"placeholder="{{label}}"type ="text"data-bv-checkUnsafeLetters="true"required="required"/>", the front-end logic JS file api.js is also similar.

S3: Read the configuration file through JdbcTemplate to connect to the database and read the table structure information.

S3.1: Create a JdbcTemplate object through the new JdbcTemplate() method, and pass in the designed connection pool information including the table name information designed in step S1 and the link address of the database: "jdbc:mysql://127.0.0.1:3360/ xxx?useUnicode=true&characterEncoding=UTF-8" and so on;

S3.2: Prepare the query table structure information statement "SELECT column_name`name`,column_comment`label`,data_type`type`,COLUMN_KEY`key`,EXTRA FROMinformation_schema.columnsWHERE table_name=?and table_schema=?"

S3.3: Use the existing JdbcTemplate object to execute the query statement database operation through the query method, and query the detailed information of the table structure according to the table constraints, including the list of fields in the business table, including column names, detailed descriptions, physical types, Java types, and Java properties The name, primary key, etc. are stored in the related storage List collection list to prepare for the use of the subsequent step S4.

S4: Generate the required code by replacing the template content with the Mustache template, and output the generated code to the corresponding path for update and release.

S4.1: Disassemble template strings and classify them. When choosing to generate code, the program will read the templates that have been created in S2 in order, and the places where key variables are used in template strings or traversal and if judgments are used must be wrapped with "{{" and "}}" The columns are like a string of form "form" template strings: "<form class="form-horizontal bv-form"id="insert-form"method="post">{{#columns}}<divclass="form- group"><label class="col-lg-2 control-label"><font color="red">*</font>{{label}}</label><div class="col-lg-8 "><input class="form-control input-sm"id="update_{{prop}}"name="{{prop}}placeholder="{{label}}"type="text"data-bv- checkUnsafeLetters="true"required="required"/></div></div>{{/columns}}</form>", ordinary strings are on the left side of "{{", so you can find " {{" to find the normal string, and then intercept. Find the position of "}}", and then intercept the loop until there is no string to intercept, so that the template string becomes the required page code after interception;

S4.2: Convert the string template into an array of tokens. The scanner receives the template content as its construction parameter, relying on the two scanner methods scan and scanUntil inside Mustache, the function of the scan method is to make the pointer skip the specified mark, and the function of the scanUtil method is to traverse characters one by one to find the specified mark, loop recursion The method obtains the string between the start delimiter and the end delimiter, as well as the string before and after the delimiter, reassembles it with "#", "/" and other related characters, and returns the string;

S4.3: Group and assemble tokens array. When a "#" character is encountered, the current token is pushed into the stack array, and the result collector is set as a subset of the token that was just pushed into the stack. When a "/" character is encountered, the latest token in the stack array is moved to the stack. Remove it, and set the result collector as a subset of the token at the top of the stack in the stack array, or the final structure set. If it is not a "#" or "/" character, directly add the current token into the result set and return The assembled tokens array;

S4.4: Render template strings into code files according to tokens. Loop tokens, ordinary strings, and directly concatenate them. If the property of the parent object is used to access the property of the object, use the lookup method to dynamically access the deep properties of the object in the form of a string, parse the loop in the string template, and finally generate a good string and finally render it as a code file.

S5: Output the code file to the specified directory, republish the code for compilation and deployment.

Finally, it should be noted that: the above is only a preferred embodiment of the present invention, and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, for those skilled in the art, it still The technical solutions recorded in the foregoing embodiments may be modified, or some technical features thereof may be equivalently replaced. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included within the protection scope of the present invention.

Claims (6)

1. The code generating method based on the database and the Mustache template engine comprises a database data reading module, a template file creating module, a Mustache template engine analyzing module and a file output module, and is characterized by comprising the following steps of:

s1, a user creates required database table structure information in advance according to business needs;

s2, creating template code files for requirements according to a project structure, wherein the template code files comprise a database persistent layer related mapping code template mapper.xml, a persistent layer processing code template mapper.java, an entity class BO code template entity.java and a business logic layer processing code template service.java, which are related to a back end, and page files related to a front end comprise front-end page code files such as html, vue and js;

s3, reading configuration files through JdbcTemplate, connecting database reading table structure information, and storing the configuration files in a data structure;

s4, analyzing the contents of the replacement template through a Mustache template engine to generate a required code, and outputting the generated code to a corresponding path;

and S5, compiling, running and releasing the code for creating the update to the server.

2. The method for generating codes based on the database and the Mustache template engine according to claim 1, wherein the description database in step S1 is not limited to commonly used mysql, oracle, pgsql, etc., and the database table structure designs corresponding fields according to the content of the service requirement.

3. The method for generating codes based on the database and the Mustache template engine according to claim 1, wherein the template scheme described in step S2 is based on any framework, and generates the required project code file according to the project requirement and the project structure, and includes:

s2.1: xml mainly comprises related requirement methods such as adding, deleting, modifying and checking corresponding to xml constraint, and the like, and required table names and fields are replaced by { { XXX } }'; java is a Class object structure containing a method corresponding to mapper.xml, and the introduced Jar packet structure and related BO contents are replaced by "{ { XXX } }";

s2.2: the method comprises the steps that a business logic layer in a project structure processes design and creation of a code template, wherein the template service is java, a Class object structure comprises a corresponding method called by an external interface, corresponding participation parameter and an entity DTO are replaced by a template character string '{ { XXX } }';

s2.3: designing and creating an entity class code template in a project structure, wherein a template entity class BO code file is in one-to-one correspondence with a database table structure field through a {/idColumn } } and { ^ idColumn } } cycle;

s2.4: and (3) designing and creating a front-end file template in the project structure, replacing field contents in the pitch < div > by using "{ { XXX } } for page template files default. Html or page.vue, and replacing related contents by using" { { first Up } } "for front-end logic JS files api. JS.

4. The database and Mustache template engine-based code generation method according to claim 1, wherein step S3 describes that the configuration file is read through jdbcttemplate to connect with database read table structure information, the jdbcttemplate encapsulates JDBC database interaction operations, a JDBC loading driver is mainly encapsulated to create a database data source driver manager database source, and the JDBC driving step injects a driver class name for the JDBC attribute; comprises the following steps:

s3.1: creating a JdbcTemplate object by a new JdbcTemplate () method, wherein the introduced designed connection pool information comprises the table name information designed in the step S1 and the link address of the database: "jdbc: mysql:// 127.0.0.1;

s3.2: compiling a query table structure information statement "SELECT COLUMN _ name ', COLUMN _ comment', data _ type ', COLUMN _ KEY', extract FROM information _ schema, COLUMNs WHERE table _ name = 'XXX' and table _ schema = 'XXX';

s3.3: and executing the operation of inquiring the statement database by using the existing JdbcTemplate object through a query method, and storing field lists including column names, detailed descriptions, physical types, java attribute names, primary keys and the like in a relevant storage List set List according to detailed information of a table structure inquired according to table constraints to prepare for the use of the subsequent step S4.

5. The method for generating codes based on the database and the Mustache template engine according to claim 1, wherein the Mustache template engine core described in S4 replaces the data content of the data table stored in the data structure with the mark content in the template file described in S2; the method is characterized in that a template is converted into a token nested array, then the tokens and data are combined to generate character strings, then the character strings are split according to different types and packaged into an array, and the detail steps of the stored character strings corresponding to Mustache engine identification information are as follows:

s4.1: disassembling the template character strings and classifying; when the generation code is selected, the program will read the created templates in S2 in sequence, and the columns wrapped by "{" and "} } are definitely used as a string of template character strings where the key variables are used or traversal and if judgment is used in the template character strings: "< ul > { # name } } < li > < dl > < dt > { # age } } { # hobbys } } < dd > { } } } } </dd > {/hobbys } } dt > </dl > </li > </ul", the common character strings are all on the left of the "{", so the common character string can be found by searching the position of the "{", and then the interception is carried out; finding the position of "}", and then intercepting a loop until no character string can be intercepted, so that the intercepted template character string becomes "< ul > { {", "xxx" and "} < li >. Once";

s4.2: converting the character string template into a token array; the scanner receives the template content as the constructed parameter, and depends on two scanner methods, namely scan and scan Until, inside the Mustache, wherein the scan method is used for enabling the pointer to skip the specified mark, and the scan Util method is used for traversing one character to search the specified mark; circularly recursion token array, acquiring character strings in front of the start separator, storing the character strings into the token array in a text mode, skipping the start separator, acquiring character strings between the start separator and the end separator, storing the character strings into the token array in a # mode if the start character is "#", storing the character strings into the token array in a/' mode if the start character is "/", skipping the end separator, obtaining the character string array after tiling grouping, and returning the character string to the token array;

s4.3: grouping and assembling tokens arrays; pushing the token character string array returned by S4.2 by applying the thought (first-in last-out/last-in first-out) of a data structure stack when meeting the "#" character, and popping when meeting the "/" character, wherein the contents between the "#" character and the "/" character are sub-elements of the character; when the "#" character is encountered, pushing the current token (the token is the attribute of a single character string after the token circulation) into the stack entry array, setting a result collector as the subset of the token which is just stacked, when the "/" character is encountered, removing the newest token in the stack array, setting the result collector as the subset of the top token in the stack array, or a final structure set, if the "#" character and the "/" character are not encountered, directly adding the current token into the result set, and returning the assembled token result set array;

s4.4: rendering the template character string into a code file according to tokens; circulating tokens, and matching a 'text' character with a common character string to directly splice; if the attribute of the 'name' character child parent object access object uses the existing lookup method to dynamically access the deep attribute on the object in the form of character strings, the analyzed character string splicing processing is obtained, if the attribute of the '#' character child parent object access object is in the form of character strings, the generated character strings are obtained through circulation in a '#' character analysis token character string template, then the character strings are spliced, and finally the spliced character strings are rendered code files.

6. The code generation method based on the database and the Mustache template engine according to claim 1, wherein in the step S5, the written character strings of the tool class are output to the file through a FileUtils file, the character strings analyzed by the parsing module of the Mustache template engine are generated into corresponding code files, and the compiling project is deployed to the server.

Images