CN113672204A - Interface document generation method, system, electronic equipment and storage medium - Google Patents
Interface document generation method, system, electronic equipment and storage medium Download PDFInfo
- Publication number
- CN113672204A CN113672204A CN202110830811.4A CN202110830811A CN113672204A CN 113672204 A CN113672204 A CN 113672204A CN 202110830811 A CN202110830811 A CN 202110830811A CN 113672204 A CN113672204 A CN 113672204A
- Authority
- CN
- China
- Prior art keywords
- interface
- interface document
- yapi
- swagger
- document generation
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 42
- 238000011161 development Methods 0.000 claims abstract description 35
- 238000004590 computer program Methods 0.000 claims description 13
- 238000004891 communication Methods 0.000 description 7
- 238000010586 diagram Methods 0.000 description 7
- 230000008569 process Effects 0.000 description 6
- 230000006870 function Effects 0.000 description 5
- 230000008901 benefit Effects 0.000 description 3
- 230000008859 change Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 238000012827 research and development Methods 0.000 description 2
- 238000000926 separation method Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 210000001503 joint Anatomy 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 238000003032 molecular docking Methods 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000004088 simulation Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
- G06F9/4451—User profiles; Roaming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4482—Procedural
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Computing Systems (AREA)
- Library & Information Science (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides an interface document generation method, a system, electronic equipment and a storage medium, wherein the technical scheme of the method comprises a development environment configuration step, namely configuring an easy Yapi plug-in a Java integrated development environment; a specification framework configuration step, namely adding a Swagger specification framework dependence in a Java project in the Java integrated development environment, and integrating the easy Yapi plug-in and the Swagger specification framework dependence; and generating an interface document, namely uploading interface information through the easy Yapi plug-in and generating the interface document on the Yapi. The method and the device solve the problem that the existing front-end and back-end interface coordination method is poor in accuracy, instantaneity and detail.
Description
Technical Field
The invention belongs to the technical field of interfaces, and particularly relates to an interface document generation method, an interface document generation system, electronic equipment and a storage medium.
Background
With the rapid development of the internet, the display and interaction experience of a front-end page is more and more flexible and glaring, the response experience is also required to be higher and higher, and the requirements of characteristics such as high concurrency, high availability, high performance and high expansion of a back-end service are also stricter, so that the research and development of the front end and the back end are respectively focused on the deep ploughing detailed work of the field which is good at the self, and the separation of the front end and the back end becomes an industry standard use mode of the internet project development.
The advantage of front-end separation is that a set of api can be reused by multiple clients, and division of labor and cooperation are refined, thereby greatly improving the coding efficiency. However, another problem is also presented: the two parties pay little attention, and are respectively managed under the condition of no api (Application Programming Interface) convention specification, so that the working load of api joint debugging and docking at the front end and the rear end is about 30% -50% or even higher in the product project development process. How to improve the working efficiency of front and rear end api joint debugging and butt joint becomes the key of the whole product project research and development.
In order to solve the problems, a front-end and back-end collaboration mode is developed on the basis of an api document, an interface document is written and maintained by the back end, and the interface document is updated when the api changes; the back end develops an interface according to the interface document; the front end carries out development + Mock (data simulation) platform according to the interface document; and (5) joint debugging and submitting a test after the development is finished. Through the interface document, when developing, a front end engineer and a rear end engineer have a unified file to communicate, exchange and develop; during maintenance, later-stage personnel can check and maintain conveniently.
However, in the prior art, the traditional interface document is basically produced by hand writing by the back end. In the process of compiling the document, due to artificial carelessness, a certain field of the interface document or a certain interface name is wrongly written, and the subsequent joint debugging operation can be influenced by the errors. In the process of project development, when a back-end person provides an interface document and the back-end person is also in joint debugging with a front-end person, but the back-end interface is changed due to requirement change, the back-end person is likely to be lazy and does not update the interface document in real time, so that the front-end person cannot modify the interface document according to the latest interface document, and the requirement change of the whole project cannot be effectively completed. When writing an interface document, basically, there will be a standard including an interface name, a method type, an entry type, a return value, a description of various situations of the return value, and the like. The general company can compel people to write according to the requirements through the interface document specification, but the ideal is very beautiful, and the reality is very harsh. Over time, the number of iterations of the project is excessive, or the period of the project is too frequent, and so on, it is difficult to write the interface document completely according to the specification. Due to the lack of specification and detailed description of the interface document, the demander of the interface document is troubled.
Disclosure of Invention
The embodiment of the application provides an interface document generation method, an interface document generation system, electronic equipment and a storage medium, and aims to at least solve the problems of poor accuracy, instantaneity and detail of the existing front-end and back-end interface coordination method.
In a first aspect, an embodiment of the present application provides an interface document generating method, including: a development environment configuration step, namely configuring an easy Yapi plug-in a Java integrated development environment; a specification framework configuration step, namely adding a Swagger specification framework dependence in a Java project in the Java integrated development environment, and integrating the easy Yapi plug-in and the Swagger specification framework dependence; and generating an interface document, namely uploading interface information through the easy Yapi plug-in and generating the interface document on the Yapi.
Preferably, the specification framework configuring step further includes: in the Java project, Swagger dependency is introduced through a pot file, an @ enableoopenapi annotation is added to project program start entry Application, and Swagger configuration is further added to the interface information to add the Swagger specification framework dependency.
Preferably, the specification framework configuring step further includes: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
Preferably, the interface document generating step further includes: and if the interface information is changed, repeatedly executing the interface document generation step to update the interface document on the Yapi.
In a second aspect, an embodiment of the present application provides an interface document generation system, which is applicable to the above interface document generation method, and includes: the development environment configuration module is used for configuring an easy Yapi plug-in a Java integrated development environment; the specification framework configuration module is used for adding a Swagger specification framework dependence in a Java project in the Java integrated development environment and integrating the easy Yapi plug-in and the Swagger specification framework dependence; and the interface document generation module uploads interface information through the easy Yapi plug-in and generates an interface document on the Yapi.
In some embodiments, the specification framework configuration module further comprises: in the Java project, Swagger dependency is introduced through a pot file, an @ enableoopenapi annotation is added to project program start entry Application, and Swagger configuration is further added to the interface information to add the Swagger specification framework dependency.
In some embodiments, the specification framework configuration module further comprises: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
In some embodiments, the interface document generation module further comprises: and if the interface information is changed, repeatedly executing the interface document generation module to update the interface document on the Yapi.
In a third aspect, an embodiment of the present application provides an electronic device, which includes a memory, a processor, and a computer program stored on the memory and executable on the processor, where the processor, when executing the computer program, implements an interface document generation method as described in the first aspect.
In a fourth aspect, the present application provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the computer program implements an interface document generating method according to the first aspect.
The method and the device can be applied to the technical field of data capacity. Compared with the prior art, the interface document generation method provided by the embodiment of the application starts from the problem of actual product project development, and aims to solve the problems that an api document and an actual code in the product project development are inconsistent, cannot be changed timely according to requirements, cannot be described in standard details and the like. Compared with other api document generation methods, the method has the following advantages:
1. when the api is changed, the modification is flexible;
2. modifying a back-end code, wherein the front end can sense the change in real time through an automatically generated api document;
3. the product item code is kept consistent with the api document at the time.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
FIG. 1 is a flow chart of an interface document generation method of the present invention;
FIG. 2 is a block diagram of an interface document generation system of the present invention;
FIG. 3 is a block diagram of an electronic device of the present invention;
in the above figures:
1. a development environment configuration module; 2. a specification framework configuration module; 3. an interface document generation module; 60. a bus; 61. a processor; 62. a memory; 63. a communication interface.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the present application will be described and illustrated below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments provided in the present application without any inventive step are within the scope of protection of the present application.
It is obvious that the drawings in the following description are only examples or embodiments of the present application, and that it is also possible for a person skilled in the art to apply the present application to other similar contexts on the basis of these drawings without inventive effort. Moreover, it should be appreciated that in the development of any such actual implementation, as in any engineering or design project, numerous implementation-specific decisions must be made to achieve the developers' specific goals, such as compliance with system-related and business-related constraints, which may vary from one implementation to another.
Reference in the specification to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the specification. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of ordinary skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments without conflict.
Unless defined otherwise, technical or scientific terms referred to herein shall have the ordinary meaning as understood by those of ordinary skill in the art to which this application belongs. Reference to "a," "an," "the," and similar words throughout this application are not to be construed as limiting in number, and may refer to the singular or the plural. The present application is directed to the use of the terms "including," "comprising," "having," and any variations thereof, which are intended to cover non-exclusive inclusions; for example, a process, method, system, article, or apparatus that comprises a list of steps or modules (elements) is not limited to the listed steps or elements, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Swagger is a standard and complete framework for generating, describing, calling and visualizing RESTful (Representational State Transfer, a design style and development mode of Web applications) style Web services. Meanwhile, Swagger follows the OpenAPI specification, which is an item of the Linux foundation, and attempts to specify the RESTful service development process by defining a language for describing the api format or api definition.
Through the set of specifications, only the interface and the information related to the interface need to be defined according to the specification. And then, through a series of projects and tools derived by the Swagger, interface documents in various formats can be generated, codes of clients and servers in various languages, online interface debugging pages and the like can be generated.
YApi is an efficient, easy-to-use and powerful api management platform and aims to provide more elegant interface management service for development, products and testers. The API can be created, published and maintained easily by developers, excellent interactive experience is provided for users by YApi, and the developers can manage the interfaces only by using an interface data writing tool and simple clicking operation provided by a platform.
The whole method flow is realized based on the Swagger specification framework, the EasyYapi plug-in and the Yapi interface management platform.
Embodiments of the invention are described in detail below with reference to the accompanying drawings:
fig. 1 is a flowchart of an interface document generating method of the present invention, please refer to fig. 1, the interface document generating method of the present invention includes the following steps:
s1: the easy yapi plug-in is configured in a Java integrated development environment.
In specific implementation, the embodiment of the application uses a Java integrated development environment IDEA, and an easy Yapi plug-in is installed in the IDEA.
S2: adding a Swagger specification framework dependency in a Java project in the Java integrated development environment, and integrating the easy Yapi plug-in and the Swagger specification framework dependency.
Optionally, in the Java project, a Swagger dependency is introduced through a pot file, an @ enablopenapi annotation is added to a project program start entry Application, and a Swagger configuration is further added to the interface information to add the Swagger canonical framework dependency.
Optionally, the step of configuring the specification framework further includes: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
In specific implementation, adding a Swagger specification framework support to a Java project, introducing Swagger dependency through a pot file, adding an @ enablopenapi annotation to a project start entry Application, enabling the project to start the Swagger specification framework, optionally configuring information such as a required title, document description, version and the like at the front end of the Swagger in the project, and finally adding Swagger related configuration to an Api interface, wherein the related configuration comprises main annotations @ Api and @ ApiOperation. The annotation @ Api is used for an Api interface large class, and the parameter tags is used for explaining the functions of the series of Api interfaces; the note @ ApiOperation is used for a specific api interface under the series, and the parameter value is used for explaining the specific function of the api.
S3: and uploading interface information through the easy Yapi plug-in and generating an interface document on the Yapi. Optionally, if the interface information is changed, the interface document generation step is repeatedly executed to update the interface document on the Yapi.
In the specific implementation, an easy Yapi plug-in is used for automatically generating an api document to a Yapi interface management platform, selecting and uploading an api interface to be uploaded, inputting a token of a corresponding item imported into the Yapi interface management platform, and checking the corresponding interface on the Yapi interface management platform after success. In specific implementation, if the api interface is changed, such as modified, newly added, deleted, and the like, the api interface can be repeatedly executed, and the api interface is uploaded to the Yapi interface management platform again, so that the corresponding document on the Yapi interface can be updated.
It should be noted that the steps illustrated in the above-described flow diagrams or in the flow diagrams of the figures may be performed in a computer system, such as a set of computer-executable instructions, and that, although a logical order is illustrated in the flow diagrams, in some cases, the steps illustrated or described may be performed in an order different than here.
The embodiment of the application provides an interface document generation system, which is suitable for the interface document generation method. As used below, the terms "unit," "module," and the like may implement a combination of software and/or hardware of predetermined functions. Although the means described in the embodiments below are preferably implemented in software, an implementation in hardware or a combination of software and hardware is also possible and contemplated.
Fig. 2 is a block diagram of an interface document generation system according to the present invention, please refer to fig. 2, which includes:
development environment configuration module 1: the easy yapi plug-in is configured in a Java integrated development environment.
In specific implementation, the embodiment of the application uses a Java integrated development environment IDEA, and an easy Yapi plug-in is installed in the IDEA.
Specification framework configuration module 2: adding a Swagger specification framework dependency in a Java project in the Java integrated development environment, and integrating the easy Yapi plug-in and the Swagger specification framework dependency.
Optionally, in the Java project, a Swagger dependency is introduced through a pot file, an @ enablopenapi annotation is added to a project program start entry Application, and a Swagger configuration is further added to the interface information to add the Swagger canonical framework dependency.
Optionally, the step of configuring the specification framework further includes: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
In specific implementation, adding a Swagger specification framework support to a Java project, introducing Swagger dependency through a pot file, adding an @ enablopenapi annotation to a project start entry Application, enabling the project to start the Swagger specification framework, optionally configuring information such as a required title, document description, version and the like at the front end of the Swagger in the project, and finally adding Swagger related configuration to an Api interface, wherein the related configuration comprises main annotations @ Api and @ ApiOperation. The annotation @ Api is used for an Api interface large class, and the parameter tags is used for explaining the functions of the series of Api interfaces; the note @ ApiOperation is used for a specific api interface under the series, and the parameter value is used for explaining the specific function of the api.
The interface document generation module 3: and uploading interface information through the easy Yapi plug-in and generating an interface document on the Yapi. Optionally, if the interface information is changed, the interface document generation module 3 is repeatedly executed to update the interface document on the Yapi.
In the specific implementation, an easy Yapi plug-in is used for automatically generating an api document to a Yapi interface management platform, selecting and uploading an api interface to be uploaded, inputting a token of a corresponding item imported into the Yapi interface management platform, and checking the corresponding interface on the Yapi interface management platform after success. In specific implementation, if the api interface is changed, such as modified, newly added, deleted, and the like, the api interface can be repeatedly executed, and the api interface is uploaded to the Yapi interface management platform again, so that the corresponding document on the Yapi interface can be updated.
In addition, one interface document generation method described in connection with fig. 1 may be implemented by an electronic device. Fig. 3 is a block diagram of an electronic device of the present invention.
The electronic device may comprise a processor 61 and a memory 62 in which computer program instructions are stored.
Specifically, the processor 61 may include a Central Processing Unit (CPU), or A Specific Integrated Circuit (ASIC), or may be configured to implement one or more Integrated circuits of the embodiments of the present Application.
The memory 62 may be used to store or cache various data files that need to be processed and/or used for communication, as well as possible computer program instructions executed by the processor 61.
The processor 61 implements any of the interface document generation methods in the above embodiments by reading and executing computer program instructions stored in the memory 62.
In some of these embodiments, the electronic device may also include a communication interface 63 and a bus 60. As shown in fig. 3, the processor 61, the memory 62, and the communication interface 63 are connected via a bus 60 to complete communication therebetween.
The communication port 63 may be implemented with other components such as: the data communication is carried out among external equipment, image/data acquisition equipment, a database, external storage, an image/data processing workstation and the like.
The bus 60 includes hardware, software, or both to couple the components of the electronic device to one another. Bus 60 includes, but is not limited to, at least one of the following: data Bus (Data Bus), Address Bus (Address Bus), Control Bus (Control Bus), Expansion Bus (Expansion Bus), and Local Bus (Local Bus). By way of example, and not limitation, Bus 60 may include an Accelerated Graphics Port (AGP) or other Graphics Bus, an Enhanced Industry Standard Architecture (EISA) Bus, a Front-Side Bus (FSB), a Hyper Transport (HT) Interconnect, an ISA (ISA) Bus, an InfiniBand (InfiniBand) Interconnect, a Low Pin Count (LPC) Bus, a memory Bus, a microchannel Architecture (MCA) Bus, a PCI (Peripheral Component Interconnect) Bus, a PCI-Express (PCI-X) Bus, a Serial Advanced Technology Attachment (SATA) Bus, a Video Electronics Bus (audio Electronics Association), abbreviated VLB) bus or other suitable bus or a combination of two or more of these. Bus 60 may include one or more buses, where appropriate. Although specific buses are described and shown in the embodiments of the application, any suitable buses or interconnects are contemplated by the application.
The electronic device may execute an interface document generation method in the embodiment of the present application.
In addition, in combination with the interface document generation method in the foregoing embodiments, the embodiments of the present application may provide a computer-readable storage medium to implement. The computer readable storage medium having stored thereon computer program instructions; the computer program instructions, when executed by a processor, implement any of the interface document generation methods in the above embodiments.
And the aforementioned storage medium includes: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.
The technical features of the embodiments described above may be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the embodiments described above are not described, but should be considered as being within the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.
Claims (10)
1. An interface document generation method, comprising:
a development environment configuration step, namely configuring an easy Yapi plug-in a Java integrated development environment;
a specification framework configuration step, namely adding a Swagger specification framework dependence in a Java project in the Java integrated development environment, and integrating the easy Yapi plug-in and the Swagger specification framework dependence;
and generating an interface document, namely uploading interface information through the easy Yapi plug-in and generating the interface document on the Yapi.
2. The interface document generation method according to claim 1, wherein the specification framework configuration step further includes: in the Java project, Swagger dependency is introduced through a pot file, an @ enableoopenapi annotation is added to project program start entry Application, and Swagger configuration is further added to the interface information to add the Swagger specification framework dependency.
3. The interface document generation method according to claim 2, wherein the specification framework configuration step further includes: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
4. The interface document generating method according to claim 1, wherein the interface document generating step further comprises: and if the interface information is changed, repeatedly executing the interface document generation step to update the interface document on the Yapi.
5. An interface document generation system, comprising:
the development environment configuration module is used for configuring an easy Yapi plug-in a Java integrated development environment;
the specification framework configuration module is used for adding a Swagger specification framework dependence in a Java project in the Java integrated development environment and integrating the easy Yapi plug-in and the Swagger specification framework dependence;
and the interface document generation module uploads interface information through the easy Yapi plug-in and generates an interface document on the Yapi.
6. The interface document generation system of claim 5, wherein the specification framework configuration module further comprises: in the Java project, Swagger dependency is introduced through a pot file, an @ enableoopenapi annotation is added to project program start entry Application, and Swagger configuration is further added to the interface information to add the Swagger specification framework dependency.
7. The interface document generation system of claim 6, wherein the specification framework configuration module further comprises: the Swagger configuration comprises an annotation @ Api and an @ ApiOperation, wherein the annotation @ Api is used for an interface large class, and the annotation @ ApiOperation is used for a specific interface.
8. The interface document generation system of claim 5, wherein the interface document generation module further comprises: and if the interface information is changed, repeatedly executing the interface document generation module to update the interface document on the Yapi.
9. An electronic device comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the processor implements the interface document generation method according to any one of claims 1 to 4 when executing the computer program.
10. A computer-readable storage medium on which a computer program is stored, the program, when executed by a processor, implementing the interface document generation method according to any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110830811.4A CN113672204A (en) | 2021-07-22 | 2021-07-22 | Interface document generation method, system, electronic equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110830811.4A CN113672204A (en) | 2021-07-22 | 2021-07-22 | Interface document generation method, system, electronic equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113672204A true CN113672204A (en) | 2021-11-19 |
Family
ID=78539826
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110830811.4A Pending CN113672204A (en) | 2021-07-22 | 2021-07-22 | Interface document generation method, system, electronic equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113672204A (en) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113971024A (en) * | 2021-12-24 | 2022-01-25 | 云账户技术(天津)有限公司 | Interface management method, device, electronic equipment and readable storage medium |
| CN114443129A (en) * | 2021-12-30 | 2022-05-06 | 广东南方新媒体科技有限公司 | Project document automatic generation method, device and storage medium |
| CN114461298A (en) * | 2022-01-17 | 2022-05-10 | ***股份有限公司 | Interface technology standard document generation method and system |
| CN117034900A (en) * | 2023-09-27 | 2023-11-10 | 厦门星纵数字科技有限公司 | Automatic generation method of API (application program interface) code file, terminal equipment and storage medium |
-
2021
- 2021-07-22 CN CN202110830811.4A patent/CN113672204A/en active Pending
Non-Patent Citations (1)
| Title |
|---|
| HERESTAY: "Swagger2配合YAPI自动生成文档", pages 1 - 15, Retrieved from the Internet <URL:https://blog.csdn.net/herestay/article/details/89338483> * |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113971024A (en) * | 2021-12-24 | 2022-01-25 | 云账户技术(天津)有限公司 | Interface management method, device, electronic equipment and readable storage medium |
| CN114443129A (en) * | 2021-12-30 | 2022-05-06 | 广东南方新媒体科技有限公司 | Project document automatic generation method, device and storage medium |
| CN114461298A (en) * | 2022-01-17 | 2022-05-10 | ***股份有限公司 | Interface technology standard document generation method and system |
| CN117034900A (en) * | 2023-09-27 | 2023-11-10 | 厦门星纵数字科技有限公司 | Automatic generation method of API (application program interface) code file, terminal equipment and storage medium |
| CN117034900B (en) * | 2023-09-27 | 2023-12-26 | 厦门星纵数字科技有限公司 | Automatic generation method of API (application program interface) code file, terminal equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN113672204A (en) | Interface document generation method, system, electronic equipment and storage medium | |
| CN104794048A (en) | Automatic UI testing method and system | |
| US8756407B2 (en) | Configuration rule prototyping tool | |
| CN110020358B (en) | Method and device for generating dynamic page | |
| CN106990960A (en) | Code dispositions method and device | |
| CN113076096A (en) | Desktop application program development method, device, equipment and storage medium | |
| CN111143446A (en) | Data structure conversion processing method and device of data object and electronic equipment | |
| AU2015331030A1 (en) | System generator module for electronic document and electronic file | |
| WO2017036348A1 (en) | Method and device for compressing and decompressing extensible markup language document | |
| CN105589959A (en) | Form processing method and form processing system | |
| CN104516864A (en) | Report generating method and report generating device | |
| CN107357588B (en) | Object code generation method and device | |
| CN106776779B (en) | Method for generating entity file by JSON data based on Mac platform | |
| CN102779045A (en) | Interface generating method, interface editor and electronic equipment | |
| CN109597603A (en) | A kind of requirement documents automatic generation method based on document component | |
| CN113177095A (en) | Enterprise knowledge management method, system, electronic equipment and storage medium | |
| CN110989999A (en) | Code generation method and device, electronic equipment and medium | |
| KR100762712B1 (en) | Method for transforming of electronic document based on mapping rule and system thereof | |
| CN106796591B (en) | Method and apparatus for unifying information and tools from multiple information sources | |
| CN111124883A (en) | Test case library introduction method, system and equipment based on tree form | |
| CN115857914A (en) | Method, equipment and storage medium for automatically generating codes | |
| CN115599388A (en) | API (application programming interface) document generation method, storage medium and electronic equipment | |
| US9052906B2 (en) | Modularized customization of a model in a model driven development environment | |
| CN112632266B (en) | Data writing method and device, computer equipment and readable storage medium | |
| CN114201157A (en) | Method and system for customizing target service module by low code |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |