CN111666072A

CN111666072A - Software code and document robot method

Info

Publication number: CN111666072A
Application number: CN202010516037.5A
Authority: CN
Inventors: 周扬; 何湘东
Original assignee: Nanjing Yiwu Intelligent Technology Co ltd
Current assignee: Nanjing Yiwu Intelligent Technology Co ltd
Priority date: 2020-06-09
Filing date: 2020-06-09
Publication date: 2020-09-15

Abstract

The invention aims to provide a software code and document robot method, which abstracts front-end codes into interface codes, event processing codes, Services codes and Models codes, automatically scans springMVC framework codes by reflection and compilation principle technology to generate Services and Models codes and can generate technical interface documents. The method can realize the automatic generation of the software development code, save programmers from the complicated and repetitive code writing, and enable the programmers to concentrate on the creative code writing; meanwhile, the technical interface document is automatically generated, boring time for a programmer to write codes is saved, the interface document is automatically updated along with the change of the system requirement change version, and the communication and cooperation efficiency of front-end and back-end developers is improved.

Description

Software code and document robot method

Technical Field

The invention relates to the field of software research and development, in particular to a software code and document robot method.

Background

With the popularization of social informatization degree, informatization is introduced in more and more fields to improve production efficiency, and in the process of popularizing informatization, software becomes an important and indispensable tool; on the other hand, as the popularity of China gradually disappears with the development of society, the labor cost is higher and higher, and the labor cost of software developers who master professional information skills is even higher. In the development process of a software project, how to improve the coding efficiency of developers and how to improve the team cooperation efficiency are long-term concerns of the software industry.

In a traditional development mode, developers with different capability levels are engaged in the development of modules with different difficulties during software development, and codes are written by programmers. The horizontal abilities of different developers are different, and the coding habits of different developers are different in style, so that software development companies have to restrict the system by issuing various system specifications, the effect is very small, and finally the quality of software codes is difficult to control. In addition, all codes need to be written by programmers, so that the efficiency is low, the product delivery cycle is long, the labor cost is high, and the market competitiveness of enterprises is influenced.

As the mobile internet permeates to various industries, various systems such as the mobile internet, the industrial internet, the internet of things and the like constructed based on a web mode need to use a web development technology. Currently, a mainstream web system development mode is carried out in a front-end and back-end separation mode, namely, the system is divided into a front end (part displayed on a browser end) and a back end (a server or a platform end), a front-end developer and a back-end developer are separated, two different team members adopt different technologies to develop system functions in parallel, the basis of cooperative communication of the front-end developer and the back-end developer is based on interfaces agreed by both parties, and the interfaces cooperate in an interface document mode.

In a traditional front-end and back-end separated development mode, after a back-end developer finishes coding, compiling a technical interface document; and then, the technical interface document is sent to a front-end development team member, and the front-end developer carries out interface docking development according to the interface document. Therefore, a plurality of problems are generated, for example, time is needed for writing interface documents, and front-end developers need to wait for the back-end to develop and write the documents, so that the efficiency is reduced; secondly, the interface document needs to be frequently updated when the interface changes due to the requirement change of the project development process, and the situations of untimely update, missing update, error update and the like are easily caused, so that wrong codes are written out by front-end development.

Disclosure of Invention

Aiming at the problems, the invention provides a software code and document robot method which can replace or assist programmers to complete code compiling and technical interface document compiling, improve software development efficiency, shorten software product delivery cycle and reduce later-stage software maintenance cost.

The invention relates to a software code and document robot method, which comprises the following steps:

model code automatic generation method:

firstly, a file reader reads an entity class source code file, wherein the entity class source code file comprises definition of an entity class;

secondly, the Model scanner obtains a member variable list of the entity class and the comments, names, types and the like of each member of the member variable list by using the reflection or compiling technology;

thirdly, the Model generator constructs a Model code file according to ts (or js) grammar based on the entity class information acquired in the last step, and the code file can be further submitted to a code base through tools such as git and the like and acquired by a front-end development programmer in a team; the Model is stored in the Model library at the same time, and the Model library is used for storing and searching the entity class of the whole item.

The method for automatically generating the Service code comprises the following steps:

firstly, reading an interface source code file by a file reader, wherein the interface comprises definition of the interface;

secondly, the Service scanner obtains annotations, comments and class method lists of the interface class and annotations, comments, names, return value types, parameter lists and the like of each method of the class method lists by using a reflection or compiling technology, wherein the parameter lists of each method are composed of parameter names and parameter types; the parameter type is either a basic type or an entity type in a Model library;

and thirdly, the Service generator constructs a Service code file according to ts (or js) grammar based on the interface class information acquired in the last step, wherein the parameter type and the return value type definition of each method are acquired by searching the type definition in a Model library if the type definition is not the basic type. The code file may be further submitted to a code library through a git or other tool, and acquired by a front-end development programmer in the team

The automatic generation method of the technical interface document comprises the following steps:

secondly, obtaining annotations, comments and class method lists of the interface class and annotations, comments, names, return value types, parameter lists and the like of each method of the class method lists by using a compiling technology through a Service scanner, wherein the parameter lists of each method are composed of parameter names and parameter types; the parameter type is either a basic type or an entity type in a Model library;

and thirdly, constructing a document description message according to a defined document format by the document generator based on the interface class information acquired in the last step, wherein the parameter type and the return value type definition of each method are acquired by retrieving the type definition from a Model library if the method is not the basic type.

The interface document generated by the document generator is sent to an online interface document cooperation platform through network messages, and the platform is responsible for analyzing and storing the automatically generated document by the robot and providing functions of online browsing, inquiring, editing, grouping and the like.

The invention has the beneficial effects that: the method can substitute software development members to automatically complete the compiling work of front-end part codes, can automatically generate technical interface documents required by front-end and back-end development butt joint, improves the software development efficiency, shortens the delivery cycle of software products and reduces the maintenance cost of later software.

Drawings

FIG. 1 is a software code and document robot framework diagram;

FIG. 2 is a diagram of a front-end and back-end development interaction module architecture;

FIG. 3 is a diagram of a front-end and back-end development interaction program;

FIG. 4 is a front end code module architecture diagram;

FIG. 5 is a diagram of an HTTP interface module architecture;

FIG. 6 is a Model code generation flow diagram;

FIG. 7 is a Service code generation flow diagram;

fig. 8 is an interface document generation flow chart.

Detailed Description

The invention is further described below with reference to the accompanying drawings.

For the sake of clarity of the description of the invention, we describe our invention embodiment specification based on one possible front-end and back-end development language, where the back-end uses java language and the front-end uses HTML, JS or TS language.

As shown in fig. 2, a typical web development program is composed of a front-end development part and a back-end development part, and a simple abstract definition is performed on modules related to the front-end and back-end development parts, wherein a front-end code is responsible for processing the definition of elements of an interface, the definition of interface styles, the processing of action events such as clicking, dragging and sliding of elements in the interface, and the acquisition and submission of data are completed by interaction between a network interface and the back end; the back-end code is responsible for processing business logic, storing and reading data, generally adds data cache on physical storage for better performance, provides a service interface for front-end access, provides data storage and acquisition capability and a business logic processing interface, and generally uses an SOA mode for processing.

The front end and the back end are interacted based on network messages, and the messages are interacted in a Restful mode under the SOA mode, namely the messages are interacted based on an HTTP + JSON or HTTP + XML mode, wherein the HTTP is responsible for transmitting the messages, and the JSON or XML is responsible for describing the content format of the messages. The direct interactive HTTP protocol of the front end and the back end of different systems is a standard protocol, JSON or XML is also a standard format, the difference lies in that the content of each transmitted message is different, and the message content carried by each request and the message content returned by the response are defined as a data model.

As shown in fig. 3, we further describe the front-end and back-end development program model that we propose, in a system development case based on a B/S architecture, a user interface generally uses HTML that can run in a browser to describe elements of the user interface, and describes the style of the user interface through CSS; event action processing of an element component on the user interface, for example, clicking an action on a button on the user interface, and performing logic processing of an event by using js (javascript) or ts (typescript), where data may need to be acquired from a back end for display in the event logic processing process, and data processed at a front end, a form input by a user, and the like may also be submitted to the back end for storage; the method comprises the steps that a part interacting with a back end in event processing is defined as a Services module, the Services module is composed of a plurality of Services, each Service represents an interface interacting with the back end, each Service comprises HTTP transmission and contents transmitted on the HTTP, specifically a message body of an HTTP request and a message body of an HTTP response, and the Services is defined as Models.

In summary, as shown in fig. 2 and fig. 3, the present invention abstracts the front-end code development in a front-end and back-end separated mode, and defines the front-end code development as an interface layout HTML code, an interface style CSS code, an interface practice processing JS/TS code, an interface call Service, a data transmission HTTP channel, and a data Model for HTTP transmission. These components are divided into three parts: the HTTP transmission is a tool with unchangeable standard protocol definition, and the HTTP can be written in advance; layout and style of the user interface and event action processing of user interface components are that each item of each interface is different and is finished by programmers and UI designers; each interface of each item of Service and Model is also changed, but the interfaces are Service interfaces written by a back-end programmer, and the interfaces can be derived through codes written by the back-end programmer, which is also the key point of the invention.

The present invention defines one of the java classes in the backend code describing the system entity as an entity class, corresponding to the content of the body of the request or response message transmitted over the HTTP protocol in fig. 2. The method for distinguishing whether a java class belongs to an entity class can be identified by annotation identification, class naming rule identification or identification by storing the entity class in a specific named packet name. In a backend code implemented based on the SpringMVC development framework, the entity class is also called entity Bean.

The present invention defines one of the java classes in the backend code to provide Restful interface to the outside as an interface class, corresponding to the method (or URL) of the request transmitted over the HTTP protocol in fig. 2. The method for distinguishing whether a java class belongs to an interface class can be identified by annotation identification, class naming rule identification or identification by storing the interface class in a specially named packet name. In a backend code implemented based on the SpringMVC development framework, the interface class is also called Controller class.

Based on the above model definition of front-end software development, as shown in fig. 1, the software code and document robot device proposed by the present invention comprises the following parts:

code & document robot: responsible for automatically generating code and interface documents, including: the system comprises a file reader, a file writer, a Model scanner, a Service scanner, a Model code generator, a Service code generator, a Model library and an interface generator.

The file reader is responsible for reading a source code of a back-end program and reading the source code into a memory so as to facilitate the next processing.

The file writer is responsible for writing the generated Model code or Service code into a file to generate a front-end source code file which is ended by js or ts and can be directly used.

In the above Model scanner, for the entity class, the annotation, the class name, the member variable of the class, the method of the class, and the annotation of each member variable and method are identified by using the reflection technique or the compiler principle and technique for the source code file read by the file reader in the memory, where each member variable includes: variable names, variable types, variable annotations, etc.; each method comprises the following steps: method name, return value type, number of parameters, type of each parameter, name of each parameter, etc.

The Model code generator generates js/ts codes which can be directly called by a front end through the Model code generator based on the information of each entity class identified by the Model scanner, the front end codes are called as Model codes in the invention, and the Model codes are message bodies for describing front-end and back-end interaction.

The Service scanner identifies annotations, comments, class names, class methods and method comments of the interface classes through a reflection technology or a compiler principle and technology for the interface classes in a source code file read by a file reader in an internal memory, wherein each method comprises the following steps: comments on methods, method names, return value types, number of parameters, type of each parameter, name of each parameter, etc.

The Service code generator generates js/ts codes which can be directly called by a front end through the Service code generator based on the information of each interface class identified by the Service scanner, the front end codes are called Services codes, and the Services codes are message methods, URLs and the like for describing front-end and back-end interaction.

The information of each entity class scanned by the Model scanner is stored in the Model library, which in one embodiment may be stored by a database (e.g., Mysql). The purpose of Model storage is that in the subsequent interface generation or Service generation process, the request parameter entity and the response entity of each interface will change, and the condition that the entity class is included in the entity class also occurs, so that the message parameter format of the interface is constructed by inquiring the entity class.

The interface generator generates a code of each Service based on the Service code generator to form an interface description message, and uploads the interface description message to the online interface collaboration platform to form an automatically generated online interface document.

An online document collaboration platform: and the interface description data is analyzed to form the online interface cooperation functions of interface storage, display, query, editing and the like. The method comprises the following steps: interface parser, interface classifier, interface querier, interface editor, interface exporter, account management, project management, rights management, etc.

The interface resolver is responsible for resolving the interface description information uploaded by the interface document generator, and resolving HTTP Method, URL, Request Body, Response Body and the like of each interface.

The interface classifier is responsible for classifying the interfaces so as to facilitate online cooperative reading, defaults to put the interfaces in the same interface class into a group, and can change the group through a user interface provided by an online interface document cooperation platform.

The interface querier is responsible for inquiring the interface provided by the online interface document cooperation platform for team members conveniently, and can support inquiring according to methods, URLs, groups and the like.

The interface editor is responsible for editing operation of interfaces, such as grouping change and interface description information change, which is provided by the online interface document cooperation platform and is convenient for team members to carry out.

The interface exporter is responsible for exporting the interface into a word or pdf document, so that project data can be conveniently filed.

The account management is responsible for providing a user account management function, and is matched with project management and authority management to finish the team member to log in and see the interface document of the participating project.

The project management is matched with project management and authority management to finish the login of team members to see the interface documents of the participating projects.

The authority management is matched with project management and authority management to finish the login of team members to see the interface documents of the participating projects.

As shown in FIG. 4, the HTTP interface code abstraction is defined as the Method, URL, Request Model, Response Model, and other attributes of HTTP.

The above-mentioned include: POST, GET, PUT and DELETE. In one embodiment, the backend code is implemented based on a SpringMVC framework, and the Method obtains the Method value of the @ RequestMapping annotation on the Method for obtaining the class of Spring through reflection or compilation technology.

The URL represents a requested resource in a Restful style interface, a back end code of one embodiment is realized based on a SpringMVC framework, a URL path accessed by an interface is defined by acquiring @ RequestMapping notes of Spring through a reflection or compilation technology, and the URL of the interface is formed by combining the @ RequestMapping notes on a class and the values of the @ RequestMapping notes on a class method;

the RequestModel obtains a request parameter list of a class method through a compiling technology, judges whether the type of each parameter in the list is a basic type (int, string, etc.) or a self-defined entity type (inquired in a Model library), finds a corresponding entity type definition in the Model library if the type of each parameter in the list is the self-defined entity type, obtains a name, an annotation and a member variable list of the type, and each member variable in the member variable list comprises the type, the name, the annotation, etc., and continues to the Model library to search for the definition of the member variable and expand the definition if the member variable is still the self-defined entity type. Through the information, the entity class can be converted into a Request Body in JSON format as the Body of the HTTP Request.

The Response Model obtains the return type of the class method through a compiling technology, the return type judges whether the class is a basic type (int, string, etc.) or a custom entity class (inquired in a Model library), if the class is the custom entity class, a corresponding entity class definition is found in the Model library, and the name, the annotation and a member variable list of the class are obtained, wherein each member variable of the member variable list comprises the type, the name, the annotation, and the like. Through the information, the entity class can be converted into a Response Body in JSON format as a Body of HTTP Response.

The compiling technology is that a compiling principle technology is used, lexical analysis and syntactic analysis are carried out on a source code to construct a syntax tree, and then Token, member, function and the like related to the code are obtained through analysis; in a possible embodiment, the method does not need to write codes by self, and the lexical analysis, the syntactic analysis and the building of a syntax tree are carried out at night, and the javadoc tool provided by oracle corporation is directly used for analysis.

As shown in fig. 6, the flow of Model code generation:

firstly, a file reader reads an Entity class source code file, such as an Entity.

Secondly, obtaining a member variable list of the Entity and the annotation, name, type and the like of each member of the member variable list by using the reflection or compiling technology through a Model scanner;

thirdly, constructing an entry.ts code file by the Model generator according to ts (or js) grammar based on the Entity information acquired in the last step, wherein the code file can be further submitted to a code library through tools such as git and the like and acquired by a front-end development programmer in a team;

the Model is stored in the Model library at the same time, the Model library is used for storing and retrieving the entity class of the whole item, and one embodiment can use the mysql database to realize the function of the Model library.

As shown in fig. 7, the Service code generation flow:

firstly, a file reader reads an Interface source code file, such as an Interface.

Secondly, obtaining comments, annotations and a class method list of the Interface class and comments, annotations, names, return value types, parameter lists and the like of each method of the class method list by using the reflection or compiling technology through a Service scanner, wherein the parameter list of each method comprises parameter names and parameter types; the parameter type is either a basic type or an entity type in a Model library;

and thirdly, the Service generator constructs an interface.ts code file according to ts (or js) grammar based on the Interface class information acquired in the last step, wherein the parameter type and the return value type definition of each method are defined, and if the parameter type and the return value type are not the basic type, the Service generator needs to retrieve the type definition from a Model library to acquire the parameter type and the return value type. The generated Service code file can be further submitted to a code base through tools such as git and the like and is obtained by a front-end development programmer in the team;

as shown in fig. 8, the interface document generation flow:

Secondly, obtaining comments, annotations and class method lists of the Interface class and comments, annotations, names, return value types, parameter lists and the like of each method of the class method lists by using the compiling technology through a Service scanner, wherein the parameter lists of each method are composed of parameter names and parameter types; the parameter type is either a basic type or an entity type in a Model library;

generating an Interface document is different from generating a Service Interface code, and here, reflection technology cannot be used for acquiring Interface type information, because annotation is very important for the document, and annotation of the code cannot be acquired through the reflection technology and can only be acquired through compiling technology.

And thirdly, constructing a document description message according to a defined document format by the document generator based on the Interface class information acquired in the last step, wherein the parameter type and the return value type definition of each method are acquired, and if the method is not the basic type, the method needs to be acquired by retrieving the type definition from a Model library.

Embodiments of the present invention describe a software code and document robot method. Any changes or substitutions that may be easily made by one skilled in the art within the technical scope of the present disclosure are intended to be included within the scope of the present disclosure. The protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. A software code and document robotic method, comprising the steps of:

A. dividing a front-end development program code into a Model code, a Service code, an event processing code and an interactive interface code;

B. the robot automatically generates a Model code and a Service code in front-end development and a technical interface document for front-end and back-end butt joint.

2. A software code and document robotic method as claimed in claim 1, wherein: step B the Model code generation steps are:

thirdly, the Model generator constructs a Model code file according to the entity type information acquired in the last step and the front-end development language grammar; the Model is stored in the Model library at the same time, and the Model library is used for storing and searching the entity class of the whole item.

3. A software code and document robotic method as claimed in claim 1, wherein: step B, the step of generating the Service code is as follows:

and thirdly, the Service generator constructs a Service code file according to ts (or js) grammar based on the interface class information acquired in the last step, wherein the parameter type and the return value type definition of each method are acquired by searching the type definition in a Model library if the type definition is not the basic type.

4. A software code and document robotic method as claimed in claim 1, wherein: step B the step of generating the technical interface document is:

thirdly, the document generator constructs a document description message according to a defined document format based on the interface class information acquired in the last step, wherein the parameter type and the return value type of each method are defined, and if the method is not a basic type, the method needs to be acquired by retrieving the type definition from a Model library;