A distributed application development method, device, equipment and storage medium

Abstract

The embodiments of this specification relate to the field of computers, and in particular, to a distributed application development method, device, equipment, and storage medium. The method includes obtaining and integrating historical field information to generate a data dictionary and a code template; performing interface development based on the data dictionary to obtain interface information; generating a code document based on the code template; verifying the code document according to the historical field information, and if the verification passes, merging multiple code documents according to the interface information to obtain a code product for release. Through the embodiments of this specification, the problem that the styles of each developer are different in the prior art, resulting in the code being difficult to maintain, is solved. It is realized that the interface document can be maintained in a timely manner after secondary development through interface release, ensuring that the corresponding interfaces between the front end and the back end match.

Description

Technical Field

[0001] This specification relates to the field of computers, and in particular, to a distributed application development method, apparatus, device, and storage medium. Background Art

[0002] Currently, in banking business requirements, a large number of new core replacements and upgrades are needed. During the upgrade process, a microservices architecture is introduced. With the implementation of the distributed microservices architecture, although the development mode has been improved, some problems have also been introduced: The traditional development method is insufficient to meet the existing requirements. To meet the needs of distributed microservices application development, a new development method is required to solve the above problems. In existing distributed application development solutions, usually, the documents of the interfaces to be developed (such as Excel documents) are prepared in advance, and then, according to the fields in the interface documents, the supporting data dictionaries are searched, and then the specific interface models are developed and converted and configured to complete the development of the interfaces.

[0003] For the above interface development solution, in the process of generating interfaces based on documents, there are many repetitive operations, such as the process of searching for each field in the document from the data dictionary, which results in low efficiency of interface development; and different microservices may be written by different developers, and there are differences in the styles of each developer, which leads to the resulting code being difficult to maintain; after the interface is released, secondary development is based on the generated code, and the interface documents cannot be maintained in a timely manner, resulting in chaotic version control, and even problems such as mismatches between the front-end and back-end corresponding interfaces.

[0004] There is an urgent need for a distributed application development method to solve the problems of low development efficiency, difficult subsequent code maintenance, and chaotic version management in the prior art caused by different developers. Summary of the Invention

[0005] To solve the problems of low development efficiency, difficult subsequent code maintenance, and chaotic version management in the prior art, the embodiments of this specification provide a distributed application development method, apparatus, device, and storage medium, which can use the data dictionary and code templates, and combine the new code after each update to generate a code document with a unified architecture, so as to form a unified and compatible code document and interface in secondary development or multiple developments, improve the order of version management, and improve the utilization rate of resources and the efficiency of development.

[0006] To solve the above technical problems, the specific technical solutions of this specification are as follows:

[0007] On the one hand, the embodiments of this specification provide a distributed application development method, including,

[0008] Obtaining and integrating historical field information to generate a data dictionary and code templates;

[0009] Develop interfaces based on the data dictionary to obtain interface information;

[0010] Generate code documents based on the code template;

[0011] Verify the code documents according to the historical field information. If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

[0012] Furthermore, obtaining historical field information for integration to generate a data dictionary further includes:

[0013] Obtain historical field information, confirm the business name corresponding to each piece of historical field information, and generate a dictionary list;

[0014] Analyze the data type, length, and precision of each piece of historical field information, and store them in the corresponding dictionary list according to their business names;

[0015] According to the data type, length, and precision of multiple pieces of historical field information under each business name, calculate the value range corresponding to each business name, and store it under the dictionary list to generate the data dictionary.

[0016] Furthermore, obtaining historical field information for integration to generate a code template further includes:

[0017] Obtain historical field information and confirm the business name corresponding to each piece of historical field information;

[0018] Define the same fields in multiple pieces of historical field information with the same business name as keywords;

[0019] Store the keywords as a code template according to the corresponding business name.

[0020] Furthermore, developing interfaces based on the data dictionary to obtain interface information further includes

[0021] Obtain the interface class name and interface name according to the business name in the data dictionary;

[0022] Obtain interface input / output parameter information according to the value range in the data dictionary;

[0023] Generate the interface information according to the data dictionary with the interface class name, interface name, and interface input / output parameter information.

[0024] Furthermore, compiling according to the code template to obtain code documents further includes

[0025] Obtain the business name corresponding to the required code, and obtain the code template according to the business name;

[0026] Compile based on the code template to generate the complete code and store it as a code document.

[0027] Further, the specific steps for verifying the code document according to the historical field information are as follows:

[0028] Extract features from each piece of historical field in the historical field information to obtain a collection of historical field features;

[0029] Extract features from the code document to obtain the code features of the code document;

[0030] Compare the code features of the code document with the code features of each piece of historical field in the collection of historical code features;

[0031] If there is a piece of historical field information in the collection of historical code features whose code similarity with the code features of the code document is higher than the threshold, the verification passes;

[0032] Otherwise, the verification fails.

[0033] Further, verifying the code document according to the historical field information further includes:

[0034] If the verification fails, manually verify the code document;

[0035] If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

[0036] Further, manually verifying the code document further includes:

[0037] If the manual verification passes, store the code document as historical field information, supplement it to the corresponding data dictionary and code template, and merge multiple code documents according to the interface information to obtain a code product for release;

[0038] If the manual verification fails, recompile the code document.

[0039] On the other hand, an embodiment of this specification also provides a device for distributed application development, including:

[0040] A system management module for obtaining historical field information for integration to generate a data dictionary and a code template;

[0041] An interface development module for developing an interface based on the data dictionary to obtain interface information;

[0042] A code generation module for compiling according to the code template to obtain a code document;

[0043] A code release module, configured to verify the code document according to the historical field information, and if the verification is passed, merge multiple code documents according to the interface information to obtain a code product for release.

[0044] On the other hand, an embodiment of the present specification further provides a computer device, including a memory, a processor, and a computer program stored on the memory. When the processor executes the computer program, the above method is implemented.

[0045] Finally, an embodiment of the present specification further provides a computer storage medium, on which a computer program is stored. When the computer program is run by the processor of the computer device, the above method is executed.

[0046] By using the embodiments of the present specification, distributed application development is realized. Moreover, in order to reduce the maintenance difficulty of the code and the matching degree of the interfaces, the requirements for standardizing the code and the interfaces are used to integrate and calculate the information in the historical fields, so as to obtain the code formats and various parameters in the historical fields of the historical versions in different services, generate a data dictionary and a code template, ensure that in the process of generating new code, the code formats in the historical fields and the code content that does not need to be updated can be directly called, and there is no need to regenerate new code, thereby improving the development efficiency of the application. At the same time, new interface information is generated according to the data dictionary generated by various parameters in the historical version. At the same time, the historical fields in the historical field information can also perform preliminary verification on the code. For some code documents with little or no changes, the verification can be directly passed, reducing the workload of manual review. If the content in the code does not conform to the historical version data, the reviewer is notified for review. For the content that passes the review, it can be reversely stored as historical field information and a dictionary list is generated in the data dictionary corresponding to the business name, realizing standardized distributed application development. This solves the problem in the prior art that the styles of each developer are different, resulting in the difficulty of maintaining the finally obtained code. At the same time, it solves the problems that the interface document cannot be maintained in time after secondary development through the interface release, resulting in chaotic version control, and even the mismatch between the front-end and back-end corresponding interfaces. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] In order to more clearly illustrate the technical solutions in the embodiments of the present specification or the prior art, the following will briefly introduce the drawings required for the description of the embodiments or the prior art. Obviously, the following drawings are only some embodiments of the present specification. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0048] Figure 1 The following shows a schematic structural diagram of a distributed application development system according to an embodiment of the present specification;

[0049] Figure 2 The figure shows a flowchart of a distributed application development method according to an embodiment of this specification;

[0050] Figure 3 The figure shows a flowchart of the detailed steps for generating a data dictionary according to an embodiment of this specification;

[0051] Figure 4 The figure shows a flowchart of the detailed steps for generating a code template according to an embodiment of this specification;

[0052] Figure 5 The figure shows a flowchart of developing an interface based on the data dictionary to obtain interface information according to an embodiment of this specification;

[0053] Figure 6 The figure shows the steps for verifying the code document according to an embodiment of this text specification;

[0054] Figure 7 The figure shows a structural schematic diagram of a device for distributed application development according to an embodiment of this specification;

[0055] Figure 8 The figure shows a structural schematic diagram of a computer device according to an embodiment of this specification.

[0056]

Explanation of the reference numerals

[0057] 101, Development port;

[0058] 102, Review port;

[0059] 103, Release port;

[0060] 701, System management module;

[0061] 702, Interface development module;

[0062] 703, Code generation module;

[0063] 704, Code release module;

[0064] 802, Computer device;

[0065] 804, Processing device;

[0066] 806, Storage resource;

[0067] 808, Driving mechanism;

[0068] 810, Input / output module;

[0069] 812, Input device;

[0070] 814, Output device;

[0071] 816. Presentation device;

[0072] 818. Graphical user interface;

[0073] 820. Network interface;

[0074] 822. Communication link;

[0075] 824. Communication bus. Detailed implementation manners

[0076] Next, the technical solutions in the embodiments of this specification will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of this specification. Obviously, the described embodiments are only a part of the embodiments of this specification, rather than all the embodiments. Based on the embodiments in this specification, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of this specification.

[0077] It should be noted that the terms "first", "second", etc. in the description and claims of this specification and the above accompanying drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged under appropriate circumstances, so that the embodiments of this specification described here can be implemented in an order different from those illustrated or described here. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusion. For example, a process, method, device, product, or equipment that includes a series of steps or units does not necessarily have to be limited to those steps or units clearly listed, but may include other steps or units not clearly listed or inherent to these process, method, product, or equipment.

[0078] As Figure 1The following is a schematic structural diagram of a distributed application development system according to an embodiment of this specification, which may include a development port 101, an audit port 102, and a release port 103. There are multiple development ports 101, which are used to provide distributed development ports for developers. Each development port 101 is respectively connected to the audit port 102, and is used to send code documents to the audit port 102 for auditing. After the audit is passed, multiple code documents are aggregated to the release port for merging, and finally the merged code product is released. At the same time, this system can use asynchronous processing technology to improve the concurrent processing ability of the system. In the prior art, there is no unified data dictionary and code template in the development port 101. Each developer develops code according to his own habits, which will lead to the code being difficult to maintain in the end, and there is no interface of the same version, resulting in chaotic version control during secondary development, and even problems such as mismatches between the front-end and back-end corresponding interfaces, increasing the difficulty of version update and reducing the work efficiency of developers.

[0079] In the embodiment of this specification, all historical field information of historical versions is stored in the development port 101. During the development process of developers, all existing codes can be called. At the same time, there is a data dictionary generated according to the historical field information in the audit port 102, which can perform preliminary verification on the code documents. If the code document to be verified is not included in the data dictionary, it may also be new content or modules written by developers. Then, the audit port 102 needs to send the code document to the auditor for manual audit. If the audit is passed, this code document is stored as a new version in the historical field information, and a new data dictionary and code template are regenerated. If the audit is not passed, the development port 101 corresponding to the code is traced according to the interface information, and the developer of this development port 101 is required to modify or optimize it, and then the steps of verification and audit are performed again. In addition, after the code merging and release are completed at the release port 103, errors or matching problems may still occur during the actual operation of the complete code product. Then, according to the information of the development port carried by the interface information in the code, this module can be traced back to the development port 101 for development, and the corresponding developer can make improvements to reduce the process of different developers doing repetitive work.

[0080] In the embodiments of this specification, the development port 101, the review port 102, and the release port 103 all run on a server. The server can be an independent physical server, a server cluster or a distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, content delivery networks (CDNs), and big data and artificial intelligence platforms.

[0081] In addition, it should be noted that in actual applications, Figure 1 the application environment shown can be applied to application development, mini-program development, document generation, etc., and this specification does not make any restrictions.

[0082] To solve the problems existing in the prior art, the embodiments of this specification provide a distributed application development method, device, equipment, and medium. Figure 2 The figure shows a flowchart of a distributed application development method provided by the embodiments of this specification, which describes the process of guiding personnel. The order of steps listed in the embodiments is only one way among the execution orders of numerous steps and does not represent the only execution order. When the actual system or device product is executed, it can be executed in the order shown in the embodiments or the drawings, or in parallel. Specifically, as Figure 2 shown, the method may include:

[0083] Step 201: Obtain historical field information for integration to generate a data dictionary and a code template;

[0084] Step 202: Develop an interface based on the data dictionary to obtain interface information;

[0085] Step 203: Generate a code document based on the code template;

[0086] Step 204: Verify the code document according to the historical field information. If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

[0087] Using the embodiments of this specification, distributed application development is realized. Moreover, in order to reduce the maintenance difficulty of the code and the matching degree of the interfaces, the code and the interfaces are required to be standardized. The information in the historical fields is integrated and calculated to obtain the code formats and various parameters in the historical fields of the historical versions in different services, and a data dictionary and a code template are generated. This ensures that during the process of generating new code, the code formats in the historical fields and the code content that does not need to be updated can be directly called, and there is no need to regenerate new code, thus improving the development efficiency of the application. At the same time, new interface information is generated according to the data dictionary generated from various parameters in the historical versions. Meanwhile, the historical fields in the historical field information can also preliminarily verify the code. Some code documents with little or no changes can directly pass the verification, reducing the workload of manual review. If there is content in the code that does not conform to the historical version data, the reviewer is notified for review. The content that passes the review can be reversely stored as historical field information and a dictionary list is generated in the data dictionary corresponding to the business name, realizing standardized distributed application development. This solves the problem in the prior art that the styles of each developer are different, resulting in the code being difficult to maintain. At the same time, it solves the problems that the interface document cannot be maintained in a timely manner after secondary development through the interface, causing chaos in version control, and even the interfaces corresponding to the front end and the back end do not match, etc.

[0088] In the embodiments of this specification, the development port 101 and the review port 102 are allocated according to the permissions corresponding to the user identities of the operators. Therefore, identity authentication needs to be performed before the operators carry out development. Among them, the reviewer has the permissions to write historical field information, manage the allocation of development ports, and review the code documents that do not pass the verification. Ordinary developers have the permissions to view the data dictionary and carry out development. After the development is completed, it needs to be submitted for verification by the review port. That is to say, in the same operation terminal, different operations can be set as the development port 101 or the review port 102 according to the user identity of the operator.

[0089] According to an embodiment of this specification, in order to unify the interface format and standardize the data in the interface development process, it is necessary to obtain the interface information in the historical versions according to the existing data in the successive versions in a certain service, ensure that the interface information of the updated version matches the previous version, and calculate the value range of the data in this service, which can be used to verify the correctness of the data in all code products after they are completed. Specifically, to obtain the data dictionary, it is necessary to obtain the historical field information for integration to generate the data dictionary and the code template. The detailed steps of generating the data dictionary are as follows Figure 3 shown, specifically as:

[0090] Step 301: Obtain the historical field information, confirm the business name corresponding to each piece of historical field information, and generate a dictionary list;

[0091] Step 302: Parse the data type, length, and precision of each piece of historical field information, and store them in the corresponding dictionary list according to their business names;

[0092] Step 303: Calculate the value range corresponding to each business name according to the data type, length, and precision of multiple pieces of historical field information under each business name, and store it under the dictionary list to generate the data dictionary.

[0093] In the embodiment of this specification, the historical field information is the code products of previous generations saved in the entire system, which includes all code documents and interface information in the code products of previous generations. After traversing the code products of each version, the information in the code products is summarized. According to the name of the code product, its corresponding business meaning and product name are confirmed, and the data types, lengths, and precisions contained therein are integrated and summarized, and stored under the corresponding business name according to the corresponding relationship. Then, according to the data lengths and precisions of all data under this business name, the value range of the data length and precision in this business name is calculated and stored to generate a complete data dictionary. Exemplarily, the data dictionary is maintained in batches through a document (such as Excel), which can be automatically generated by the system or pre-organized by the reviewer. The document mainly includes data dictionary name, data type, length, precision, Chinese name, business meaning, value range information. An example table of the Excel data dictionary file is shown in Table 1:

[0094] Table 1

[0095] English Name Chinese Name Business Meaning Data Type Length Precision Value Range BRANCH Institution Code Institution Code VARCHAR 20 0 Parameter Table

[0096] According to an embodiment of this specification, in step 201, the historical field information is obtained and integrated to generate a data dictionary and a code template. The detailed steps for generating the code template are as follows:

[0097] Step 401: Obtain the historical field information and confirm the business name corresponding to each piece of historical field information;

[0098] Step 402: Define the same fields in multiple pieces of historical field information with the same business name as keywords;

[0099] Step 403: Store the keywords as a code template according to the corresponding business name.

[0100] The purpose of generating the code template is to avoid developers having to repeatedly input the same content during development, or to prevent the resulting code from being difficult to maintain due to different developers writing simultaneously with different thought processes. Therefore, the code documents in previous versions are summarized. The repeated identical fields may be common code fields or basic frameworks in this business. Thus, the repeated fields are defined as code templates according to their corresponding functions, and keywords are set for storage. When developing at the development port, the code template is called through the keyword, reducing the repetitive work content of developers.

[0101] Exemplarily, the code template consists of keywords and template tags. The program can generate code based on the template and parameters. The specific information is as follows

[0102]

[0103]

[0104] It also includes a file template:

[0105]

[0106] According to an embodiment of the present specification, as Figure 5 shown, the specific steps for interface development based on the data dictionary to obtain interface information include:

[0107] Step 501: Obtain the interface class name and interface name according to the business name in the data dictionary;

[0108] Step 502: Obtain the interface input and output parameter information according to the value range in the data dictionary;

[0109] Step 503: Generate the interface information based on the interface class name, interface name, and interface input and output parameter information according to the data dictionary.

[0110] Since a unified data dictionary is used in each business, that is, the interface information generated by each development port in each business is consistent, ensuring that the interface document can be maintained in a timely manner after the interface is published, and achieving complete consistency of the interface information in the corresponding interfaces between the front end and the back end, improving the efficiency of development and maintenance.

[0111] Exemplarily, the main information of the interface is as shown in the following table, which mainly includes interface class name, interface name, interface url, interface remarks, interface package path, input and output parameter paths, input parameters, output parameters, etc. Among them, the output parameters and input parameters must be the information defined in the data dictionary.

[0112] Table 2

[0113]

[0114]

[0115] According to an embodiment of the present specification, compiling according to the code template to obtain a code document, further including,

[0116] Obtain the business name corresponding to the required code, and obtain the code template according to the business name;

[0117] Compile based on the code template to generate complete code and store it as a code document.

[0118] After the above interface development is completed, the application administrator uses a code generation tool to perform code generation operations. Among them, the code template is compiled based on a preset coding language. The format of the above code template includes but is not limited to Java, xml, etc. During the development process of developers, the commonly used code fields in this business are usually in the retrieved code template. Therefore, developers only need to input the keywords of the code template to obtain the complete code fields of this section of code in the historical version, avoiding repetitive work. At the same time, the parts that need to be modified in the new version can also be directly modified and optimized based on the code template, ensuring that the code styles of the new and old versions are consistent and facilitating the improvement and development of subsequent versions.

[0119] According to an embodiment of the present specification, as Figure 6 shown, the specific steps for verifying the code document according to the historical field information include:

[0120] Step 601: Extract features from each piece of historical field in the historical field information to obtain a historical field feature set;

[0121] In this step, it is necessary to first obtain the abstract syntax tree of each piece of historical field in the historical field information, and then perform feature extraction based on the abstract syntax tree to obtain a historical field feature set. Regarding the method of obtaining the abstract syntax tree, in one possible implementation, when the historical field is compiled code (such as a JavaScript script), the server parses the code through a script parsing engine (such as the NodeJS engine corresponding to the JavaScript script) to obtain the abstract syntax tree. In one possible implementation, since the abstract syntax tree has many levels, in order to be able to reflect the features of different levels, the server divides the abstract syntax tree into subtrees according to the parent-child relationship between the nodes in the abstract syntax tree to obtain several abstract syntax subtrees, and performs feature extraction on each abstract syntax subtree to obtain the subtree code features corresponding to each abstract syntax subtree. Correspondingly, the finally obtained historical field feature set is composed of each subtree code feature.

[0122] Step 602: Extract features from the code document to obtain the code features of the code document;

[0123] Using the same method, first obtain the abstract syntax tree of the code document, and then perform feature extraction based on the abstract syntax tree to obtain the code features of the code document.

[0124] Step 603: Compare the code features of the code document with the code features of each historical field in the historical code feature collection;

[0125] In some embodiments, the historical field information stores the code documents corresponding to each online program. The code features of the code document are compared with the code features of each historical field in the historical code feature collection. In this embodiment, the server determines whether the code document has appeared in the historical version by calculating the similarity between the small code features.

[0126] Optionally, if there is a historical field code feature in the historical code feature collection whose similarity with the code features of the code document is higher than the threshold, it means that the code document has appeared in the historical version. For example, the threshold can be 85%. This step is to confirm whether the code document is directly generated by retrieving the existing code template in the historical version, so as to avoid the need for reviewers to review the existing code in the historical version during version updates, which reduces work efficiency.

[0127] Step 604: Determine whether there is a code feature in the historical code feature collection whose code similarity with the code features of the code document is higher than the threshold;

[0128] In this step, if there is a code feature in the historical code feature collection whose code similarity with the code features of the code document is higher than the threshold, the verification passes and step 608 is performed; otherwise, the verification fails and step 605 is executed.

[0129] Step 605: Perform manual verification and determine whether the manual verification passes;

[0130] In the case where the verification fails, the code document needs to be manually verified;

[0131] The main verification of the historical code information is the rationality of the code, including whether the spelling conforms to the specification and whether the data type (length, precision) appears in the fields of the historical version. If the verification of the historical code information fails, it means that the data type and other information in this code document do not exist in the historical version. Therefore, this code document may be new code in the new version or may be incorrect error code. Therefore, manual review is required, and the reviewer makes a judgment on whether the code is correct.

[0132] Step 606: If the manual verification passes, store the code document as historical field information, supplement it to the corresponding data dictionary and code template, and then proceed to Step 608;

[0133] In this step, if the reviewer's verification passes, it proves that this code document is the new code in the new version and the content is correct. Therefore, this paragraph can be classified as historical field information and the information in it can be supplemented to the data dictionary and code template as the basis for subsequent versions.

[0134] Step 607: If the manual verification fails, recompile the code document.

[0135] If the manual verification fails, it means that there are errors in this code document or it is not applicable to the current version. Therefore, the unapproved interfaces can be modified again and submitted for review until the review passes or the modification is abandoned;

[0136] Step 608: If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

[0137] If the verification passes, it means that the data type (length, precision) has appeared in the fields of the historical version and is the code content that has been released in the historical version. Therefore, it does not need to be submitted to the manual review port for review, which greatly reduces the workload of the reviewers and avoids repeated review of duplicate content.

[0138] Furthermore, the interface information is generated according to the unified data dictionary in each development port. That is to say, the interface information center includes the interface information required for code merging in each development port and the development port where each piece of code comes from. The development port where each piece of code comes from is stored in the review port. During the subsequent testing of the complete code document, other problems may occur. Then, the problematic code can be traced back to the original development port for modification through the stored code source in the review port, reducing the repetitive work content and improving the writing efficiency of developers. At the same time, the code generated in the above stage and the compiled products are released, and interface document / sql script export is also supported.

[0139] The embodiment of this specification also provides a distributed application development device, as Figure 7 shown, including,

[0140] A system management module 701, configured to obtain historical field information for integration and generate a data dictionary and a code template;

[0141] An interface development module 702, configured to perform interface development based on the data dictionary to obtain interface information;

[0142] A code generation module 703, configured to compile according to the code template to obtain a code document;

[0143] A code publishing module 704, configured to verify the code document according to the data dictionary, and if the verification is passed, publish the code document through the interface.

[0144] Since the principle of the above device for solving problems is similar to that of the above method, the implementation of the above device can refer to the implementation of the above method, and the repeated parts will not be described again.

[0145] As Figure 8 shown is a schematic structural diagram of a computer device according to an embodiment of the present invention. The device in this specification can be the computer device in this embodiment, and execute the method in this specification. The computer device 802 may include one or more processing devices 804, such as one or more central processing units (CPUs), and each processing unit may implement one or more hardware threads. The computer device 802 may also include any storage resource 806, which is used to store any type of information such as code, settings, data, etc. Non-limitingly, for example, the storage resource 806 may include any one or more combinations of the following: any type of RAM, any type of ROM, flash memory devices, hard disks, optical discs, etc. More generally, any storage resource can store information using any technology. Further, any storage resource can provide volatile or non-volatile retention of information. Further, any storage resource can represent a fixed or removable component of the computer device 802. In one case, when the processing device 804 executes the associated instructions stored in any storage resource or combination of storage resources, the computer device 802 can perform any operation of the associated instructions. The computer device 802 also includes one or more drive mechanisms 808 for interacting with any storage resource, such as a hard disk drive mechanism, an optical disc drive mechanism, etc.

[0146] The computer device 802 may also include an input / output module 810 (I / O), which is used to receive various inputs (via the input device 812) and provide various outputs (via the output device 814). A specific output mechanism may include a presentation device 816 and an associated graphical user interface (GUI) 818. In other embodiments, the input / output module 810 (I / O), the input device 812, and the output device 814 may not be included, and it may only be a computer device in the network. The computer device 802 may also include one or more network interfaces 820, which are used to exchange data with other devices via one or more communication links 822. One or more communication buses 824 couple the components described above together.

[0147] The communication link 822 can be implemented in any manner, for example, through a local area network, a wide area network (e.g., the Internet), a point-to-point connection, etc., or any combination thereof. The communication link 822 can include any combination of hardwired links, wireless links, routers, gateway functions, name servers, etc. governed by any protocol or combination of protocols.

[0148] corresponding to Figures 2 to 6 In accordance with the method in, an embodiment of this specification also provides a computer-readable storage medium having a computer program stored thereon, and when the computer program is run by a processor, it executes the steps of the above-described method.

[0149] An embodiment of this specification also provides a computer-readable instruction, wherein when the processor executes the instruction, the program therein causes the processor to execute as Figures 2 to 6 the method shown.

[0150] It should be understood that in various embodiments of this specification, the magnitude of the sequence numbers of the above processes does not imply the order of execution. The order of execution of each process should be determined by its function and internal logic, and should not constitute any limitation to the implementation process of the embodiments of this specification.

[0151] It should also be understood that in the embodiments of this specification, the term "and / or" is merely a description of the association relationship of associated objects, indicating that three relationships may exist. For example, A and / or B may represent: A exists alone, A and B exist simultaneously, and B exists alone. In addition, the character " / " in this specification generally represents an "or" relationship between the associated objects before and after.

[0152] Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in combination with the embodiments disclosed in this specification can be implemented by electronic hardware, computer software, or a combination of the two. To clearly illustrate the interchangeability of hardware and software, the components and steps of each example have been generally described according to their functions in the above description. Whether these functions are executed in a hardware or software manner depends on the specific application and design constraints of the technical solution. Professional technicians can use different methods to implement the described functions for each specific application, but such implementation should not be considered to exceed the scope of this specification.

[0153] Those skilled in the art can clearly understand that for the convenience and brevity of description, the specific working processes of the systems, devices, and units described above can refer to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0154] In several embodiments provided in this specification, it should be understood that the disclosed systems, devices, and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the displayed or discussed couplings or direct couplings or communication connections to each other can be indirect couplings or communication connections through some interfaces, devices, or units, and can also be electrical, mechanical, or other forms of connection.

[0155] The units described as separate components may or may not be physically separated. The components displayed as units may or may not be physical units, that is, they may be located in one place, or may be distributed to multiple network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the embodiment solutions of this specification.

[0156] In addition, each functional unit in the various embodiments of this specification can be integrated into a processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above-mentioned integrated units can be implemented in the form of hardware or in the form of software functional units.

[0157] If the above-mentioned integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this specification, in essence, or the part that contributes to the prior art, or all or part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this specification. The aforementioned storage medium includes: USB flash drives, mobile hard disks, read-only memories (ROM, Read-Only Memory), random access memories (RAM, Random Access Memory), magnetic disks, or optical disks, and other media that can store program codes.

[0158] Specific embodiments are used in this specification to elaborate on the principles and implementation manners of this specification. The descriptions of the above embodiments are only used to help understand the method and its core idea of this specification; at the same time, for those of ordinary skill in the art, according to the idea of this specification, there will be changes in the specific implementation manners and application scopes. In summary, the content of this specification should not be construed as a limitation to this specification.

Claims

1. A distributed application development method, characterized in that The method includes: Obtain historical field information for integration to generate a data dictionary and a code template; Based on the data dictionary, perform interface development to obtain interface information; According to the business names in the data dictionary, obtain interface class names and interface names; According to the value ranges in the data dictionary, obtain interface input and output parameter information; According to the data dictionary, generate the interface information from the interface class names, interface names, and interface input and output parameter information; Generate a code document based on the code template; Verify the code document according to the historical field information, Extract features from each segment of historical field information in the historical field information to obtain a historical field feature set; Extract features from the code document to obtain the code features of the code document; Compare the code features of the code document with the code features of each segment of historical field in the historical code feature set; If there is a code similarity between the code features of the historical field information in the historical code feature set and the code features of the code document that is higher than the threshold, the verification passes; Otherwise, the verification fails; If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

2. The distributed application development method according to claim 1, wherein Obtain historical field information for integration to generate a data dictionary further includes: Obtain historical field information, confirm the business name corresponding to each segment of historical field information, and generate a dictionary list; Parse the data type, length, and precision of each segment of historical field information, and store them in the corresponding dictionary list according to its business name; According to the data type, length, and precision of multiple segments of historical field information under each business name, calculate the value range corresponding to each business name, and store it under the dictionary list to generate the data dictionary.

3. The distributed application development method according to claim 1, wherein Obtain historical field information for integration to generate a code template further includes: Obtain historical field information, and confirm the business name corresponding to each segment of historical field information; Define the same fields in multiple segments of historical field information with the same business name as keywords; Store the keywords as a code template according to the corresponding business name.

4. The distributed application development method according to claim 3, wherein Compiling according to the code template to obtain a code document further includes, Obtain the business name corresponding to the required code, and obtain the code template according to the business name; Based on the code template, perform compilation to generate complete code and store it as a code document.

5. The distributed application development method according to claim 1, wherein Verifying the code document according to the historical field information further includes, If the verification fails, manually verify the code document; If the verification passes, merge multiple code documents according to the interface information to obtain a code product for release.

6. The distributed application development method according to claim 5, wherein Manually verifying the code document further includes, If the manual verification passes, store the code document as historical field information, supplement it to the corresponding data dictionary and code template, and merge multiple code documents according to the interface information to obtain a code product for release; If the manual verification fails, recompile the code document.

7. A device for distributed application development, characterized in that, Includes, A system management module for obtaining historical field information for integration to generate a data dictionary and a code template; An interface development module for developing an interface based on the data dictionary to obtain interface information; Obtaining an interface class name and an interface name according to the business name in the data dictionary; Obtaining interface input and output parameter information according to the value range in the data dictionary; Generating the interface information by using the interface class name, the interface name, and the interface input and output parameter information according to the data dictionary; A code generation module for compiling according to the code template to obtain a code document; A code publishing module for verifying the code document according to the historical field information, extracting features for each piece of historical field in the historical field information to obtain a historical field feature set; Extracting features of the code document to obtain code features of the code document; Comparing the code features of the code document with the code features of each piece of historical field in the historical code feature set; If there is a code similarity between the code features of the historical field information in the historical code feature set and the code features of the code document that is higher than the threshold, the verification passes; Otherwise, the verification fails; If the verification passes, multiple code documents are merged according to the interface information to obtain a code product for publishing.

8. A computer device, comprising a memory, a processor, and a computer program stored on the memory, characterized in that, When the computer program is run by the processor, it executes the instructions of the method according to any one of claims 1 to 6.

9. A computer storage medium, on which a computer program is stored, characterized in that, When the computer program is run by the processor of a computer device, it executes the instructions of the method according to any one of claims 1 to 6.

Images