Tool generation method and apparatus, computer device, and storage medium

Abstract

The application relates to a tool generation method and device, computer equipment and a storage medium, which comprises the following steps: generating a key element set based on key information in an interface description text; generating an interface model by performing data generation on the key element set based on a rule reasoning algorithm; constructing a calling sequence diagram based on the interface model, and optimizing the calling sequence diagram to generate a connection logic framework; adjusting abnormal processing logic in the connection logic framework to generate an enhanced logic structure; generating a construction script based on the enhanced logic structure; verifying the construction script based on a verification strategy to obtain a verification result, and generating an executable connection tool based on the verification result and the construction script; performing simulation test processing based on the connection tool to obtain test data, and determining a connection configuration corresponding to the connection tool based on the test data; and deploying the connection tool and the connection configuration to a target system. The application effectively improves the generation efficiency of the connection tool, and realizes rapid deployment of system integration.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to tool generation methods, apparatus, computer devices, and storage media. Background Technology

[0002] In today's era of rapid information technology development, system integration and data exchange between enterprises play a crucial supporting role in driving business innovation and improving operational efficiency. Whether it's the collaborative operation between various business systems within an enterprise or the information exchange between the enterprise and external partners, the demand for connectivity between different systems is constantly increasing. This connectivity is not limited to simple technical interfaces; it is a key factor in ensuring the smooth and stable operation of enterprise business processes.

[0003] However, in the process of promoting digital transformation, enterprises face the significant challenge of efficiently and securely interconnecting systems with various technical standards. While some tools and methods exist on the market designed to solve system integration problems, these solutions often prove ineffective in the face of complex and ever-changing real-world business environments. Many methods reveal deficiencies in flexibility and adaptability when dealing with different technical protocols and interface standards, failing to meet the diverse system integration needs of enterprises. More critically, accurately understanding and parsing interface description information, precisely extracting key information from the numerous and varied interface descriptions, and transforming it into directly usable connection tools (i.e., connectors) is a core issue that enterprises urgently need to address in achieving efficient system integration. However, current technologies lack automated methods for generating connection tools, typically relying on manual analysis of interface description information and the writing of connection tools. This results in low efficiency in generating connection tools and hinders rapid deployment of system integration.

[0004] Therefore, existing technologies have significant technical shortcomings in automating the generation of connectivity tools and rapidly deploying system integration. Summary of the Invention

[0005] The purpose of this application is to provide a tool generation method, apparatus, computer device, and storage medium to solve the technical problem that the lack of an automated method for generating connection tools in the prior art leads to low efficiency in generating connection tools.

[0006] Firstly, a tool generation method is provided, including:

[0007] Extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information;

[0008] The key element set is processed by a preset rule-based reasoning algorithm to generate the corresponding interface model.

[0009] Based on the interface model, a corresponding call sequence diagram is constructed, and the call sequence diagram is optimized to generate a corresponding connection logic framework;

[0010] The exception handling logic in the connection logic framework is adjusted to generate a corresponding enhanced logic structure.

[0011] Automated build scripts are generated based on the enhanced logic structure;

[0012] The build script is verified based on a preset verification strategy to obtain the corresponding verification result, and an executable connection tool is generated based on the verification result and the build script.

[0013] Based on the connection tool, a simulation test is performed to obtain the corresponding test data, and based on the test data, the connection configuration corresponding to the connection tool is determined.

[0014] Deploy the connection tool and the connection configuration to the target system.

[0015] Secondly, a tool generation apparatus is provided, comprising:

[0016] The first processing module is used to extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information.

[0017] The first generation module is used to perform data generation processing on the key element set based on a preset rule reasoning algorithm to obtain the corresponding interface model.

[0018] The second processing module is used to construct a corresponding call sequence diagram based on the interface model, and to optimize the call sequence diagram to generate a corresponding connection logic framework.

[0019] The adjustment module is used to adjust the exception handling logic in the connection logic framework and generate the corresponding enhanced logic structure.

[0020] The second generation module is used to generate automated build scripts based on the enhanced logic structure;

[0021] The third processing module is used to verify the construction script based on a preset verification strategy to obtain the corresponding verification result, and to generate an executable connection tool based on the verification result and the construction script.

[0022] The determination module is used to perform simulation test processing based on the connection tool to obtain corresponding test data, and determine the connection configuration corresponding to the connection tool based on the test data;

[0023] The deployment module is used to deploy the connection tool and the connection configuration to the target system.

[0024] Thirdly, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-described tool generation method.

[0025] Fourthly, a computer-readable storage medium is provided, which stores a computer program that, when executed by a processor, implements the steps of the above-described tool generation method.

[0026] The above-mentioned tool generation method, apparatus, computer equipment, and storage medium implement the following scheme: First, key information is extracted from the interface description text corresponding to the target system, and a corresponding key element set is generated based on the key information; then, the key element set is processed by a preset rule reasoning algorithm to obtain the corresponding interface model; next, a corresponding call sequence diagram is constructed based on the interface model, and the call sequence diagram is optimized to generate a corresponding connection logic framework; subsequently, the exception handling logic in the connection logic framework is adjusted to generate a corresponding enhanced logic structure; and an automated build script is generated based on the enhanced logic structure; further, the build script is verified based on a preset verification strategy to obtain the corresponding verification result, and an executable integration tool connection tool is generated based on the verification result and the build script; in the next step, simulation testing is performed based on the integration tool connection tool to obtain the corresponding test data, and the connection configuration corresponding to the integration tool connection tool is determined based on the test data; finally, the connection tool and the connection configuration are deployed to the preset target environment and target system. Based on the above automated processing flow, this application generates a key element set based on key information extracted from the interface description text, and uses a rule-based reasoning algorithm to generate data from the key element set to obtain an interface model. Then, the call sequence diagram built based on the interface model is optimized to generate a connection logic framework, and the exception handling logic in the connection logic framework is adjusted to generate an enhanced logic structure. Subsequently, a verification strategy is used to verify the build script generated based on the enhanced logic structure, and an executable connection tool is automatically generated based on the verification results and the build script. Following this, simulation testing is performed on the connection tool, and the connection configuration corresponding to the connection tool is determined based on the obtained test data. Finally, the generated connection tool and connection configuration are deployed to the target system. Thus, this application provides an automated generation method for accurately extracting key information from interface descriptions and transforming it into a directly usable connection tool, eliminating the need for manual analysis of interface description information and writing of connection tools, effectively improving the generation efficiency and intelligence of connection tools. Furthermore, by automatically deploying the generated connection tool and corresponding connection configuration to the target system, system integration can be quickly achieved, shortening the system integration deployment cycle, thereby realizing rapid system integration deployment and improving the efficiency and flexibility of system integration. Attached Figure Description

[0027] To more clearly illustrate the solutions in this application, the accompanying drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0028] Figure 1 This is an exemplary system architecture diagram to which this application can be applied;

[0029] Figure 2 This is a flowchart of an embodiment of the tool generation method according to this application;

[0030] Figure 3 This is a schematic diagram of the structure of one embodiment of the tool generation apparatus according to this application;

[0031] Figure 4 This is a schematic diagram of the structure of one embodiment of the computer device according to this application. Detailed Implementation

[0032] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains; the terminology used herein in the specification of the application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application; the terms "comprising" and "having," and any variations thereof, in the specification, claims, and foregoing drawings of this application, are intended to cover non-exclusive inclusion. The terms "first," "second," etc., in the specification, claims, or foregoing drawings of this application are used to distinguish different objects, not to describe a particular order.

[0033] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0034] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings.

[0035] like Figure 1 As shown, system architecture 100 may include terminal device 101, network 102, and server 103. Terminal device 101 may be a laptop 1011, tablet 1012, or mobile phone 1013. Network 102 is used as a medium to provide a communication link between terminal device 101 and server 103. Network 102 may include various connection types, such as wired, wireless communication links, or fiber optic cables, etc.

[0036] Users can use terminal device 101 to interact with server 103 via network 102 to receive or send messages, etc. Various communication client applications can be installed on terminal device 101, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social media platform software, etc.

[0037] Terminal device 101 can be various electronic devices with a display screen and support web browsing. In addition to laptops 1011, tablets 1012, or mobile phones 1013, terminal device 101 can also be an e-book reader, an MP3 player (Moving Picture Experts Group Audio Layer III), an MP4 player (Moving Picture Experts Group Audio Layer IV), a laptop computer, and a desktop computer, etc.

[0038] Server 103 can be a server that provides various services, such as a backend server that provides support for the pages displayed on terminal device 101.

[0039] It should be noted that the tool generation method provided in this application embodiment is generally executed by a server / terminal device, and correspondingly, the tool generation device is generally located in the server / terminal device.

[0040] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0041] Continue to refer to Figure 2 A flowchart illustrating an embodiment of the tool generation method according to this application is shown. The order of the steps in this flowchart can be changed, and some steps can be omitted, depending on different needs. The tool generation method includes the following steps:

[0042] Step S201: Extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information.

[0043] In this embodiment, the tool generation method runs on an electronic device (e.g., Figure 1The server / terminal device shown can obtain the interface description text via wired or wireless connection. It should be noted that the aforementioned wireless connection methods may include, but are not limited to, 3G / 4G / 5G connections, WiFi connections, Bluetooth connections, WiMAX connections, Zigbee connections, UWB (ultra-wideband) connections, and other currently known or future wireless connection methods. The implementing entity of this application can specifically be a processing system with interface description parsing and deployment functions, which can be simply referred to as the system. In complex business scenarios within enterprises, there are numerous target systems that need to be integrated and interact with each other. These target systems include internal business systems with different functions, such as financial systems, inventory systems, and sales systems, as well as systems from external partners, such as supplier platforms and customer management systems. Each target system provides corresponding interface description files to achieve connection and data interaction with other systems. These interface description files detail the structured parameters, protocol types, data formats, and calling methods of the system's interface, serving as an important basis for other systems to understand how to interact with it. Therefore, the interface description text obtained above refers to the interface description file of the target system to be deployed. The interface description text can be obtained from the API documentation link or Swagger JSON endpoint provided by the user that is related to the target system.

[0044] Specifically, an API documentation link points to a page containing interface description text: An API documentation link typically leads to a webpage that provides detailed information about the API in a human-readable format, including the interface description text. For example, an online API documentation page will describe the function of each interface, request parameters (field names, types, constraints, etc., which is parameter structure information), request methods (such as HTTP methods like GET and POST, which are protocol features), authentication methods, etc., in natural language. This text content is the interface description text. Users can see this descriptive information after clicking the link to access the page.

[0045] The Swagger JSON endpoint presents the API description text in a structured data format: Swagger is a specification for describing and documenting RESTful APIs, and the Swagger JSON endpoint returns JSON data. This JSON data contains detailed information about the API in a structured way; essentially, it's a description of the API, just presented in a machine-readable format. It also covers parameter structure (represented by specific fields in JSON to indicate field names, types, constraints, etc.) and protocol features (such as explicitly specifying HTTP methods, authentication methods, and other related fields). Before semantic analysis, this JSON data is obtained, and then the text information related to the API description is extracted and parsed to obtain the corresponding API description text.

[0046] Furthermore, the specific implementation process of extracting key information from the obtained interface description text corresponding to the target system and generating a corresponding set of key elements based on the key information will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0047] Step S202: Based on a preset rule-based reasoning algorithm, perform data generation processing on the set of key elements to obtain the corresponding interface model.

[0048] In this embodiment, the specific implementation process of the above-mentioned data generation processing of the key element set based on the preset rule reasoning algorithm to obtain the corresponding interface model will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0049] Step S203: Construct a corresponding call sequence diagram based on the interface model, and optimize the call sequence diagram to generate a corresponding connection logic framework.

[0050] In this embodiment, the specific implementation process of constructing the corresponding call sequence diagram based on the interface model and optimizing the call sequence diagram to generate the corresponding connection logic framework will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0051] Step S204: Adjust the exception handling logic in the connection logic framework to generate the corresponding enhanced logic structure.

[0052] In this embodiment, the specific implementation process of adjusting the exception handling logic in the connection logic framework to generate the corresponding enhanced logic structure will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0053] Step S205: Generate an automated build script based on the enhanced logic structure.

[0054] In this embodiment, the automated build script generation process includes: firstly, parsing the enhanced logic structure to extract its logical rules and interaction paths. The parsing process may involve layer-by-layer analysis of the enhanced logic structure, identifying each logical node and the connections between them. Through parsing, the logical rules that the system should follow when handling various situations, and how data flows between different interfaces, can be clearly understood. Then, after extracting the logical rules and interaction paths, an automated build script is generated based on these rules. An automated build script is a script program capable of automatically executing a series of operations to complete a specific task. It constructs various parts of the system based on the logical rules in the enhanced logic structure, including interface calls, error handling, and data interaction. Furthermore, the script generation process includes converting the logical rules into specific script statements, setting the script's execution order and conditional judgments, etc. This ensures that the generated build script can execute according to the predetermined logical rules.

[0055] Step S206: Verify the build script based on a preset verification strategy to obtain the corresponding verification result, and generate an executable connection tool based on the verification result and the build script.

[0056] In this embodiment, the specific implementation process of verifying the construction script based on the preset verification strategy to obtain the corresponding verification result, and generating an executable connection tool based on the verification result and the construction script will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0057] Step S207: Perform simulation test processing based on the connection tool to obtain corresponding test data, and determine the connection configuration corresponding to the connection tool based on the test data.

[0058] In this embodiment, the above-mentioned implementation process of obtaining corresponding test data by performing simulation test processing based on the connection tool, and determining the connection configuration corresponding to the connection tool based on the test data, will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0059] Step S208: Deploy the connection tool and the connection configuration to the target system.

[0060] In this embodiment, the generated connection tool (or connector) encapsulates complex calling logic, data mapping, and error handling mechanisms, serving as the core execution carrier for system integration. For example, when an enterprise integrates its internal Customer Relationship Management (CRM) system with an external marketing automation platform, the generated connection tool can handle complex operations such as interface calls and data format conversions between different systems. The generated connection configuration, on the other hand, is a set of rules that guides the connection tool on how to perform interface connections, protocol adaptation, and resource allocation. For instance, an enterprise-level connection tool has its own core components such as a data processing engine and task scheduling module; the connection configuration specifies the parameter settings for these components when handling different data source interfaces. Only by deploying the connection tool and connection configuration together to the target system can the connection tool operate according to the connection configuration. Furthermore, the protocol adaptation parameters in the connection configuration need to be parsed and executed by the protocol processing module in the connection tool. For example, if the connection configuration specifies a particular encryption protocol and authentication method for communication with an external system interface, the connection tool must have the corresponding protocol processing capabilities to establish a secure and reliable connection according to the configuration requirements. Similarly, resource allocation strategies also require the resource management module of the connection tool to implement, such as allocating appropriate CPU and memory resources for different interface tasks. Therefore, without the connection tool, connection configuration cannot function independently.

[0061] Specifically, the aforementioned target system refers to the specific software system that needs to interface with the connection tool (connector) to achieve data interaction. It is the main body for implementing business functions, possessing specific business logic and functional modules. It focuses more on the implementation of business functions and is the object of the connector's services. Examples include: internal enterprise systems such as Enterprise Resource Planning (ERP) systems, Customer Relationship Management (CRM) systems, and Supply Chain Management systems; and external partner systems such as supplier systems and logistics company systems. These systems are responsible for the core business operations of the enterprise. The role of the connection tool and connection configuration is to enable data sharing and interaction between these systems, improve the automation and collaborative efficiency of business processes, and enable smooth data interaction and business collaboration between different target systems.

[0062] The deployment process described above includes packaging all relevant files, such as the executable file of the connectivity tool, dependent libraries, and configuration files (containing the finalized connectivity configuration), into a single package. This packaged assembly is then deployed to the target system's server or container to ensure the connectivity tool runs completely and accurately on the target system, performing interface integration and connectivity operations according to the predetermined connectivity configuration. Alternatively, automated deployment tools can be used to quickly install the connectivity tool and its configuration onto the target system, such as an internal enterprise inventory system or an external vendor platform, automatically configuring data transmission parameters and protocols for rapid system integration.

[0063] Furthermore, the system can uniformly manage and deploy connection configurations across multiple target systems. When an enterprise needs to integrate systems, the system can quickly deploy the generated connection tools and configurations to various target systems according to preset rules and processes, and complete the relevant initialization work. Simultaneously, the system can monitor the deployment status of the connection tools and configurations and the operational status after system integration in real time. If any problems are detected, adjustments and optimizations can be made promptly to ensure that system integration can be deployed quickly and stably. For example, when an enterprise integrates multiple internal business systems with external partner systems, the system can deploy the connection tools and configurations to the corresponding target systems sequentially according to a predetermined plan, automatically performing configuration checks and tests during the deployment process, significantly shortening the system integration deployment cycle.

[0064] From a practical application perspective, connectors and connection configurations together meet diverse integration needs. They satisfy the needs of different business scenarios: Enterprises face diverse business scenarios and system integration requirements. Different business scenarios may require different interface call sequences, data interaction methods, and error handling strategies. The connection tool generation provides a general integration framework, while the connection configuration generation allows for customization of the connection tool according to specific business scenarios. For example, when conducting promotional activities, enterprises may need to increase the frequency of data interaction with marketing automation platforms. This can be achieved by adjusting the connection configuration without redeveloping the connection tool. They enable rapid deployment and flexible adjustment: The connection tool and configuration generation solution allows for rapid deployment and flexible adjustment of system integration. When an enterprise introduces a new business system or needs to integrate with a new partner, it only needs to generate the corresponding connection tool and configuration to quickly achieve system integration. Furthermore, if business requirements change, only the connection configuration needs to be adjusted, without modifying the connection tool's code, improving the flexibility and responsiveness of system integration.

[0065] In addition, the benefits of deployment include: breaking down data silos: The connectivity tool connects data interfaces of different systems and formats according to the connection configuration, enabling data flow and sharing. For example, integrating data from an enterprise's internal sales, inventory, and financial systems allows each department to access comprehensive business data in real time, improving the accuracy and efficiency of decision-making. Supporting business process automation: Through the connectivity tool and connection configuration, business processes are automated. For example, when a new order is generated in the sales system, the connectivity tool automatically retrieves the order data from the sales system, transforms it, and loads it into the inventory system for inventory checks. If inventory is sufficient, the shipping process is automatically triggered, and shipping information is fed back to the sales system and the customer.

[0066] Based on the above automated processing flow, this application generates a key element set based on key information extracted from the interface description text, and uses a rule-based reasoning algorithm to generate data from the key element set to obtain an interface model. Then, the call sequence diagram built based on the interface model is optimized to generate a connection logic framework, and the exception handling logic in the connection logic framework is adjusted to generate an enhanced logic structure. Subsequently, a verification strategy is used to verify the build script generated based on the enhanced logic structure, and an executable connection tool is automatically generated based on the verification results and the build script. Following this, simulation testing is performed on the connection tool, and the connection configuration corresponding to the connection tool is determined based on the obtained test data. Finally, the generated connection tool and connection configuration are deployed to the target system. Thus, this application provides an automated generation method for accurately extracting key information from interface descriptions and transforming it into a directly usable connection tool, eliminating the need for manual analysis of interface description information and writing of connection tools, effectively improving the generation efficiency and intelligence of connection tools. Furthermore, by automatically deploying the generated connection tool and corresponding connection configuration to the target system, system integration can be quickly achieved, shortening the system integration deployment cycle, thereby realizing rapid system integration deployment and improving the efficiency and flexibility of system integration.

[0067] In some alternative implementations, step S201 includes the following steps:

[0068] The interface description text is scanned to determine whether there are any ambiguous expressions in the interface description text.

[0069] In this embodiment, a preliminary scan of the interface description text can be performed to determine whether there are any ambiguous expressions. If ambiguous words or phrases are detected in the interface description text, it is determined that the interface description text contains ambiguous expressions.

[0070] If so, the interface description text is corrected based on preset semantic supplementation rules to obtain the corrected target interface description text.

[0071] In this embodiment, when ambiguous expressions are identified in the interface description text, these ambiguous expressions are corrected or supplemented according to preset semantic supplementation rules (such as context inference, default value setting, user confirmation, etc.). For example, for the parameter name "time," if its type (such as date, timestamp, etc.) is not explicitly stated in the interface description, the system will infer it as a specific type based on the context or default value setting. After correction and supplementation, the corresponding target interface description text is obtained.

[0072] The target interface description text is preprocessed and semantically analyzed based on a preset natural language processing algorithm to identify the corresponding feature information.

[0073] In this embodiment, a semantic analysis model suitable for interface description text is pre-built. This model can be fine-tuned based on a pre-trained language model (such as BERT, GPT, etc.) or combined with traditional NLP techniques (such as word segmentation, part-of-speech tagging, dependency parsing, etc.). During model training, a large amount of labeled interface description data is used, which contains explicit annotations of parameter structures and protocol features. In the actual semantic analysis process, the semantic analysis model first preprocesses the input interface description text, including removing irrelevant characters and standardizing text format. Then, it identifies entities and relationships in the interface description text through semantic analysis techniques, specifically identifying feature information such as parameter names, parameter types, parameter constraints, and protocol types. For example, for the text describing "User ID (integer type, required) is transmitted using the HTTP protocol," the model can identify that "User ID" is the parameter name, "integer type" is the parameter type, "required" is the parameter constraint, and "HTTP protocol" is the protocol type. Thus, semantic analysis can accurately understand the natural language meaning in the interface description and transform it into a structured information representation.

[0074] The feature information is classified based on a preset classification strategy to extract corresponding key information. This key information includes parameter information and protocol information.

[0075] In this embodiment, a series of predefined rules or patterns are used to match and identify the same information under different expressions. For example, for parameter types, there may be multiple expressions such as integer, int, and Integer, all of which need to be classified into the same type. Similarly, protocol identifiers may also have multiple expressions, such as HTTP and http. During the classification process, the system will traverse each word or phrase in the interface description text and match and classify them according to the predefined rules or patterns. For words or phrases that cannot be directly matched, the system will use heuristic methods or machine learning models for further analysis and judgment. Finally, the system will extract key information such as parameter name, type (parameter information), and protocol identifier (protocol information) and store it in a structured form.

[0076] The parameter information and the protocol information are integrated and standardized to construct a corresponding initial set of key elements.

[0077] In this embodiment, the aforementioned integration and standardization process includes: the system sets corresponding constraints and protocol rules for each parameter based on its parameter type and protocol type. For example, for integer parameters, constraints such as value range and whether negative numbers are allowed are set; for parameters transmitted via HTTP protocol, protocol rules such as request method (e.g., GET, POST), request header information, and response format are set. These constraints and protocol rules are integrated into a structured data structure (e.g., JSON object, XML document), forming a corresponding initial key element set. This set not only contains basic information about the parameters and protocols but also their relationships and constraints, providing comprehensive data support for the subsequent generation of connection tools and connection configurations.

[0078] The initial set of key elements is deduplicated and standardized to obtain the corresponding first set of key elements.

[0079] In this embodiment, deduplication is performed to eliminate any duplicate elements (such as identical parameter names or types) in the set, ensuring that each element is unique. Standardization, on the other hand, converts the elements in the set into a unified standard format or naming convention to facilitate subsequent interface integration and connection configuration. Specifically, the system iterates through each element in the initial key element set, checking for duplicates or non-standard formats. For duplicate elements, the system retains one and deletes the others; for elements that do not conform to the standard format, the system converts or renames them according to predefined rules. After deduplication and standardization, the system obtains a structured output, namely the aforementioned first key element set.

[0080] The first set of key elements is verified based on a preset verification strategy.

[0081] In this embodiment, the verification process includes: comparing each element in the first key element set with the corresponding part in the original interface description to check for omissions or errors. Simultaneously, the consistency and integrity of the data are checked to ensure that all necessary parameters and protocol information are included without conflict or contradiction. Furthermore, the system simulates the actual interface call process to verify the correctness of the parameters and protocols. If any problems or errors are found during the verification process, corresponding error messages are returned, prompting the user to make corrections. If the first key element set passes all verification steps, it is used as the final key element set.

[0082] If the first set of key elements passes the verification, then the first set of key elements will be used as the set of key elements.

[0083] Based on the above processing flow, this application accurately extracts key information from the interface description text by combining semantic supplementation rules with natural language processing algorithms. Then, by integrating and standardizing the key information, deduplicating and standardizing it, and taking the first set of key elements that has passed the verification as the key element set, the accuracy and standardization of the generated key element set can be effectively guaranteed.

[0084] In some optional implementations of this embodiment, step S202 includes the following steps:

[0085] The key element set is format matched based on a preset rule-based reasoning algorithm to identify the correspondence between the key element set and the preset standard template.

[0086] In this embodiment, a rule-based reasoning algorithm is pre-built. This algorithm identifies the correspondence between parameters and protocols in the key element set and a standard template based on a predefined set of rules. These rules may include mapping rules for parameter names, identification rules for protocol types, and conversion rules for data types. During the execution of the rule-based reasoning algorithm, the system traverses each element in the key element set and attempts to match it with the corresponding part in the standard template according to these rules. For example, for parameter names, the system may check whether they are the same as or similar to a parameter name defined in the standard template (considering possible naming differences); for protocol types, the system may identify the corresponding standard protocol type based on protocol identifiers or protocol characteristics. Through this step, the system can establish a preliminary correspondence between the key element set and the standard template.

[0087] If the correspondence is analyzed and a format mismatch is detected between the key element set and the standard template, the key element set is adjusted according to a preset conversion rule to obtain the corresponding second key element set.

[0088] In this embodiment, since the set of key elements may come from different sources or follow different specifications, its format may not perfectly match the standard template. Therefore, during the format matching process, if a format mismatch is found, the system will adjust the element format in the aforementioned set of key elements using preset conversion rules. These conversion rules may include data type conversion (e.g., converting strings to integers), parameter name normalization (e.g., converting abbreviations to full names), and protocol identifier unification (e.g., converting different versions of protocol identifiers to a unified standard form). During the adjustment process, the system will ensure that the converted element format is consistent with the format in the standard template and generate an adjusted second set of key elements.

[0089] If an unknown protocol type is detected in the set of key elements, then the unknown protocol type is parsed based on preset adaptation rules to generate a temporary mapping relationship corresponding to the standard template.

[0090] In this embodiment, since the interface description may contain unknown protocol types that are not defined in the standard template, the system will apply preset adaptation rules to parse the protocol when an unknown protocol type is encountered during the mapping process. These adaptation rules may include protocol feature identification, protocol structure analysis, and protocol behavior simulation. By parsing the features and behaviors of unknown protocol types, the system can generate a temporary mapping relationship to associate the unknown protocol type with a known protocol type or a custom protocol type in the standard template.

[0091] Based on the temporary mapping relationship and the standard template, the second set of key elements is integrated into a standardized target interface description.

[0092] In this embodiment, after establishing the mapping relationship (including temporary mapping relationships) between the key element set and the standard template, these elements are then integrated into a standardized interface description. Specifically, the system places each element in the key element set into its corresponding position in the standard template according to the mapping relationship and adaptation rules, and performs necessary formatting and standardization processing. For example, for parameter names and types, the system ensures that they are consistent with the definitions in the standard template; for protocol types and rules, the system ensures that they conform to the protocol specifications in the standard template. Through this step, the system can generate a target interface description that conforms to the standard template.

[0093] The target interface description is subjected to consistency verification based on a preset consistency verification strategy.

[0094] In this embodiment, the consistency check includes: the system iterates through each part of the target interface description and checks it according to the specifications and requirements of the standard template. If any inconsistencies or errors are found, the system returns the corresponding error message and prompts the user to make corrections. If the standardized interface description passes the consistency check and no problems or errors are found, it is considered a unified interface model.

[0095] If the target interface description passes the consistency check, then the target interface description is used as the interface model.

[0096] In this embodiment, after determining a unified interface model, the system intelligently checks for undefined elements. These undefined elements may be due to incomplete interface descriptions or limitations of the standard template. If undefined elements are found, the system supplements them with default configuration parameters to improve the model structure. These default configuration parameters may include default values ​​for parameters, default settings for protocols, and default rules for interface behavior. By supplementing default configuration parameters, the system ensures that the interface model has sufficient flexibility and scalability in subsequent use. Ultimately, the system obtains a complete interface model structure that conforms to the standard template specifications and contains all necessary elements and configuration parameters.

[0097] Based on the above processing flow, this application uses a combination of rule-based reasoning algorithms, transformation rules, adaptation rules, temporary mapping relationships, standard templates, and consistency verification strategies to generate data for the key element set. This enables the automatic and accurate generation of an interface model that conforms to the standard template and contains all the necessary elements and configuration parameters, ensuring the accuracy and standardization of the generated interface model.

[0098] In some alternative implementations, step S203 includes the following steps:

[0099] The interface model is parsed to extract the corresponding call order and interface dependency constraints.

[0100] In this embodiment, the interface model is a description of the various interfaces in the relevant system and their interrelationships. The parsing process of the above interface model involves a detailed analysis of the interface model layer by layer and element by element to extract key data, including the calling order and the dependency constraints between interfaces (i.e., interface dependency constraints). The calling order refers to the order in which the various interfaces are called during system operation; while the dependency constraints between interfaces describe the mutual dependencies between interfaces in terms of data, function, or control flow.

[0101] Construct a corresponding call sequence diagram based on the call order and the interface dependency constraints.

[0102] In this embodiment, an initial call sequence graph can be constructed based on the extracted call order and interface dependency constraints. A call sequence graph is a graphical representation used to show the call relationships and order between interfaces. During the construction process, the nodes in the graph are first determined; these nodes represent various interfaces in the relevant system. Then, according to the call order and interface dependency constraints, directed edges between the nodes are determined; these edges represent the call relationships between interfaces. In this way, a preliminary call sequence graph reflecting the interface call order and dependency relationships can be constructed.

[0103] The call sequence graph is analyzed to obtain the corresponding interface analysis results, and a corresponding dynamic call graph is generated based on the interface analysis results.

[0104] In this embodiment, after constructing the initial call sequence diagram, further interface analysis is performed on the call sequence diagram to obtain the call timing and data flow between each interface (i.e., the interface analysis results). The call timing refers to the specific chronological order in which interfaces are called, while the data flow describes the path of data transmission between interfaces. Furthermore, by analyzing this information in depth, a more detailed and dynamic call diagram can be generated. This dynamic call diagram not only shows the static call relationships between interfaces but also reflects the dynamic behavior of the interfaces during runtime, including the call timing and data flow.

[0105] Determine whether the dynamic call graph contains circular dependencies.

[0106] In this embodiment, after generating the dynamic call graph, it is further checked for circular dependencies. A circular dependency refers to a closed loop formed by the call relationships between interfaces, i.e., interface A calls interface B, interface B calls interface C, and interface C then calls interface A in turn. Such circular dependencies may lead to deadlocks or performance issues during system runtime.

[0107] If the dynamic call graph has circular dependencies, the call order of the dynamic call graph is optimized and adjusted based on a preset adjustment strategy to obtain the corresponding target dynamic call graph.

[0108] In this embodiment, if a circular dependency is detected in the dynamic call graph, optimization is performed by adjusting the call order within the dynamic call graph. The call order refers to the sequence in which various interfaces are called during the operation of the relevant system. It focuses on describing the temporal relationship between interface calls. For example, in a business process, calling the login interface first, then the user information retrieval interface, and finally the logout interface is a simple example of a call order. Furthermore, optimization methods may include changing the call order of interfaces, introducing intermediate interfaces, or refactoring parts of the code to eliminate circular dependencies. Optimizing the call order ensures system stability and performance.

[0109] Determine whether the call sequence corresponding to the target dynamic call graph conforms to the preset protocol adaptation requirements.

[0110] In this embodiment, after optimizing the dynamic call graph to obtain the target dynamic call graph, it is further determined whether the call sequence in the target dynamic call graph conforms to the protocol adaptation requirements. The dynamic call graph contains complete information about the interface calls, including the call order, dependencies, and possible data flow, which together constitute the call sequence. Protocol adaptation requirements typically refer to specific protocols or standards that the interface call sequence must meet. These requirements may include call order, parameter passing, error handling, etc. Specifically, by comparing the dynamic call graph with the protocol adaptation requirements, it can be determined whether the current call sequence meets the protocol adaptation requirements, and a corresponding judgment result (satisfied or not satisfied) is generated. If it does not meet the requirements, the call sequence needs further adjustment and optimization to ensure that it conforms to the protocol specification.

[0111] If so, the call sequence is logically reorganized to generate the corresponding connection logic framework.

[0112] In this embodiment, after confirming that the call sequence conforms to the protocol adaptation requirements, the call sequence is further logically reorganized. The purpose of logical reorganization is to generate a more efficient and stable connection logic framework. This framework can clearly show the call relationships and data flow between interfaces, while ensuring the overall performance and stability of the related system. During the reorganization process, strategies such as parallelizing the call sequence, introducing caching mechanisms, or optimizing data transmission methods can be used to improve the efficiency of the related system. By adopting such a logical reorganization method, an optimized connection logic framework can be generated.

[0113] Based on the above processing flow, this application processes the interface model to construct an initial call sequence diagram, generates a dynamic call diagram, optimizes the call sequence in the dynamic call diagram, determines whether it meets the protocol adaptation requirements, and finally performs logical reorganization of the call sequence to automatically and accurately generate an optimized connection logic framework, effectively ensuring the efficiency and stability of the generated connection logic framework.

[0114] In some alternative implementations, step S204 includes the following steps:

[0115] Integrity checks are performed on the error handling branches in the connection logic framework based on a preset verification matching algorithm.

[0116] In this embodiment, the connection logic framework already includes the basic framework of the call relationships between various interfaces and the error handling mechanism. To ensure the robustness of this framework, a verification matching algorithm is further used to perform integrity checks on the error handling branches in the connection logic framework. The verification matching algorithm is an algorithm capable of automatically identifying and verifying specific patterns or rules in a logical structure. Here, it is used to scan the connection logic framework, checking whether each possible error handling branch has been correctly set and whether it conforms to the predetermined error handling specifications. Through this integrity check, deficiencies or errors in the error handling mechanism can be detected and corrected in a timely manner.

[0117] If an exception handling branch is detected to be missing in the connection logic framework, a predefined rollback path is added to the connection logic framework to obtain the corresponding first connection logic framework.

[0118] In this embodiment, if certain exception handling branches are found to be missing in the connection logic framework during the integrity check process, these missing parts will be supplemented according to predefined rules. The predefined rollback path is a mechanism that allows the system to automatically revert to a previous stable state when an error occurs. These rollback paths are pre-defined during the relevant system design phase to ensure rapid recovery in case of problems. Supplementing the rollback path may involve modifying the existing logic framework, adding new error handling nodes, or adjusting the logical order of existing nodes to ensure that the relevant system can roll back according to the predetermined path in the event of an anomaly, thereby avoiding data loss or system crashes.

[0119] The compatibility of the rollback path with the main logic flow of the first connection logic framework is verified, and the corresponding verification results are obtained.

[0120] In this embodiment, after supplementing the predefined rollback paths to obtain the first connection logic framework, the compatibility of these rollback paths with the main logic flow of the first connection logic framework is further verified. This is because the rollback paths exist as a supplement to the main logic flow, and they must be able to effectively handle abnormal situations without affecting the normal operation of the main flow. Specifically, the compatibility verification process includes simulating various abnormal situations, checking whether the rollback paths can be triggered correctly, and whether the rollback operation can be completed without compromising the integrity of the main flow data. If the rollback paths can be triggered correctly and the rollback operation can be completed without compromising the integrity of the main flow data, a verification result of passing the compatibility verification will be generated. If any incompatibility is found, a verification result of failing the compatibility verification will be generated, and adjustments need to be made to the rollback paths or the main logic flow to ensure that they can work together.

[0121] If the verification result is that the compatibility verification fails, the exception handling logic in the first connection logic framework is adjusted to obtain the adjusted second connection logic framework.

[0122] In this embodiment, if the verification results are problematic, such as the rollback path failing to trigger correctly or the data integrity of the main process being compromised during rollback, it indicates a deficiency in the existing exception handling logic within the connection logic framework, requiring adjustment. Specifically, this involves the following aspects: 1) Condition judgment logic of error handling nodes: If the rollback path is not triggered correctly, it may be because the error handling node's judgment conditions for abnormal situations are not accurate or comprehensive enough. In this case, the condition judgment logic needs to be adjusted to more accurately identify various abnormal situations, thereby initiating the rollback path in a timely manner. 2) Triggering conditions for rollback paths: If the rollback path is triggered at an inappropriate time, it may cause unnecessary interference to the main process or prevent the rollback operation from being executed effectively. Based on the verification results, the triggering conditions for rollback paths need to be optimized to ensure timely and accurate triggering of rollback under appropriate abnormal conditions. 3) Method of transmitting exception information: Accurate transmission of exception information is crucial for the execution of rollback operations. If exception information is not transmitted smoothly or is erroneous, the rollback path may be unable to obtain the necessary information to complete the rollback operation. In this case, the method of transmitting exception information needs to be optimized to ensure that information is transmitted to relevant nodes in a timely and accurate manner.

[0123] The purpose of adjusting the exception handling logic is to enable it to accurately identify and handle various abnormal situations, while maintaining a high degree of consistency and coordination with the main logic flow, thereby improving the stability and reliability of the system.

[0124] The second connection logic framework is covered and verified based on a preset iterative checking strategy.

[0125] In this embodiment, after adjusting the exception handling logic, the generated second connection logic framework undergoes multiple iterative checks. Iterative checking is a method of repeatedly executing a specific test or verification process to ensure that the system meets predetermined requirements after each adjustment. The purpose of iterative checking is to confirm that all potential error scenarios have been covered by the current exception handling logic. Specifically, this may involve simulating various extreme or abnormal input conditions to check whether the relevant system can correctly identify and handle these situations. Through multiple iterative checks, deficiencies in the logic framework can be gradually discovered and corrected, thereby ensuring that the relevant system remains stable and reliable in the face of various complex situations. If it is confirmed that all potential error scenarios have been covered, the second connection logic framework is determined to have passed the coverage verification; otherwise, it is determined that the second connection logic framework has failed the coverage verification.

[0126] If the second connection logic framework passes the coverage verification, then the second connection logic framework is further refined to generate the corresponding enhanced logic structure.

[0127] In this embodiment, the aforementioned detailed refinement includes: specifying the specific parameters for each interface call, the precise path of data flow, and the specific procedures for exception handling. These refinements enable the enhanced logical structure to more accurately guide the construction of subsequent automation scripts, ensuring that the generated scripts can efficiently and accurately execute various operational tasks. For example, regarding interface call parameters, the enhanced logical structure specifies in detail the type, value range, and default value of each parameter to avoid errors in parameter generation and usage by the script.

[0128] Based on the above processing flow, this application combines integrity checks, rollback path supplementation, compatibility verification, exception handling logic adjustment, and coverage verification to process the connection logic framework and generate a corresponding enhanced logic structure. This enhanced logic structure not only includes the original interface call relationships and error handling mechanisms but has also undergone rigorous verification and optimization to ensure its stability and reliability in practical applications. Furthermore, the enhanced logic structure will serve as the foundation for subsequent automation script construction, enabling the generated automation scripts to better meet the actual needs of the system, thereby reducing script debugging and modification time and improving development efficiency.

[0129] In some optional implementations of this embodiment, step S206 includes the following steps:

[0130] The data interaction paths of the construction script are integrated to obtain the corresponding first construction script.

[0131] In this embodiment, after generating the build script, it is necessary to further integrate the data interaction paths within it to ensure the integrity of the data during the flow process. The data interaction path refers to the path through which data is transferred between different interfaces or system components. During the integration process, the script is checked to ensure that it contains all necessary data interaction steps and that these steps are executed in the correct order. If any missing or incorrect paths are found, the build script is adjusted to ensure that data can be transferred completely and accurately from one interface to another. This integration method ensures that the relevant system does not experience data loss or errors when processing data, thereby improving the stability of the relevant system.

[0132] Determine whether the first build script covers all relevant technical standards.

[0133] In this embodiment, after integrating the data interaction paths, it is also necessary to check whether the build script covers all relevant technical standards. Technical standards refer to a series of specifications and requirements that the relevant system must follow during the design and implementation process.

[0134] If the first build script does not cover all relevant technical standards, then the specific technical standards that are missing in the first build script are identified.

[0135] In this embodiment, if it is detected that the first build script does not cover all relevant technical standards, that is, if it is found that the script is missing adaptation logic for certain specified technical standards, then these missing specified technical standards will be identified.

[0136] The first build script is supplemented with adaptation logic corresponding to the specified technical standard to obtain the corresponding second build script.

[0137] In this embodiment, any missing specified technical standards in the first build script will be automatically supplemented. The process of supplementing the adaptation logic for specified technical standards includes adding new script statements or modifying the existing logical structure to ensure that the relevant system conforms to all relevant technical standards. This logic supplementation ensures that the relevant system will not experience problems or malfunctions due to non-compliance with technical standards during future use.

[0138] Perform execution verification on the second build script.

[0139] In this embodiment, the aforementioned executionability verification includes syntax verification and logic verification. Syntax verification checks for syntax errors or non-compliance in the script to ensure correct execution. Logic verification checks the rationality and compliance of the script's logic with predetermined requirements. Through syntax and logic verification, problems in the script can be identified and corrected in a timely manner, thereby ensuring its executability. If the script passes both syntax and logic verification, it is determined to have passed executionability verification. Conversely, if any errors or non-compliance are found, the script is determined to have failed executionability verification and requires corresponding modifications and adjustments until it fully complies with syntax and logic requirements.

[0140] If the second build script passes the execution verification, an executable linker is generated based on the second build script.

[0141] In this embodiment, after syntax and logic verification and confirming the executableness of the second build script, an executable linker tool is generated based on the second build script. The linker tool (or connector) is a tool capable of simulating the actual operation of a system, helping developers conduct thorough testing and verification before formal system deployment. The process of generating the linker tool includes compiling the second build script into an executable program, setting the necessary runtime environment and parameters, etc. By adopting this generation method, it is ensured that the linker tool accurately reflects the actual operation of the relevant system and provides strong support for subsequent simulation testing. After the linker tool is generated, it can be used for subsequent simulation testing.

[0142] Based on the above processing flow, this application obtains a corresponding second construction script by integrating the data interaction path and supplementing the adaptation logic of the construction script. Then, the second construction script is verified based on the use of the second verification strategy, and an executable connection tool is generated based on the second construction script that has passed the execution verification. This enables the automatic and accurate generation of the connection tool, improving the generation efficiency and accuracy of the connection tool.

[0143] In some optional implementations of this embodiment, step S207 includes the following steps:

[0144] The simulation test is performed based on the connection tool, and the corresponding execution logs are obtained.

[0145] In this embodiment, a simulation environment can be built using a connection tool to conduct simulated tests according to preset diverse test scenarios and steps. These test scenarios cover various situations that the target system (the business system requiring the deployment of the connection tool) may encounter in actual operation, such as high-concurrency user access and frequent interactions between different business modules. The connection tool will strictly follow the set process to perform operations, simulating the real system operating state.

[0146] During the simulation test, the connection tool records detailed information for each operation in real time, forming an execution log. The log includes interface call information, such as the interface name, call time, call parameters, and return results; the data interaction process, including the data source, destination, data format, and data content; and it also records potential errors or exceptions, such as the reason for interface call failure and the type of data transmission error. Simultaneously, the connection tool monitors and records the target system's performance metrics in real time, including response time (the time from initiating a request to receiving a response), throughput (the number of requests successfully processed by the system per unit time), resource utilization (the proportion of resources such as CPU, memory, and network bandwidth used), etc. These performance metrics reflect the target system's performance in the simulation test, such as the usage of resources like CPU, memory, and network bandwidth. These resources are fundamental to supporting the operation of systems requiring connector deployment.

[0147] Based on the execution logs, analyze whether there are any protocol mismatches during the simulation test.

[0148] In this embodiment, after obtaining the execution log, the log content is carefully examined line by line, focusing on the target system's interface calls, data formats, and communication protocol information. For example, it is checked whether the data format returned by a key interface during the call is consistent with expectations, and whether the communication protocol meets the system design requirements. Then, the protocol-related information recorded in the execution log is rigorously compared with the predefined protocol specifications in the target system. If it is found that the call results of some interfaces do not match expectations, or that there are differences in data formats or communication protocols, it is determined that there is a protocol mismatch. For example, the target system specifies that a certain interface should use JSON format to transmit data, but the execution log shows that XML format is actually transmitted, which indicates a protocol mismatch problem.

[0149] If a protocol mismatch exists, the protocol adaptation parameters are adjusted based on the preset specifications to obtain the corresponding target protocol adaptation parameters, and the corresponding target test configuration is generated based on the target protocol adaptation parameters.

[0150] In this embodiment, once a protocol mismatch is identified, the execution logs can be further analyzed to pinpoint the specific parameters causing the mismatch. For example, if the data encoding method is found to be mismatched, the encoding parameters that need to be adjusted are determined; if the communication protocol versions are inconsistent, the version-related parameters that need to be modified are identified.

[0151] Furthermore, based on the identified problem parameters, the protocol adaptation parameters are adjusted. Protocol adaptation parameters are key settings used to adjust the communication protocols between system components or interfaces of the target system. By modifying these parameters according to the predefined protocol specifications of the target system, the protocols between the various components and interfaces of the target system can be made compatible. For example, the data encoding method is changed from ASCII to UTF-8, and the communication protocol version is upgraded from an older version to a newer version. In addition, after adjusting the protocol adaptation parameters, a new test configuration (i.e., the target test configuration) is regenerated, including updating the parameter settings in the test scripts and modifying the test scenarios and steps to adapt to the new parameter configuration.

[0152] Based on the target test configuration, the connection tool is used to repeatedly execute the simulation test until the execution log shows that there are no protocol anomalies and the current target performance index data is obtained.

[0153] In this embodiment, the simulation test is executed again using the aforementioned connection tool based on the regenerated target test configuration, and new execution logs are recorded. The new execution logs are carefully analyzed to check for any remaining protocol mismatches. If they persist, the problematic parameters are located again, and the process of adjusting protocol adaptation parameters and reconfiguring is repeated until the execution logs show a complete protocol match and no further mismatches occur. Then, the simulation test data from the last simulation test is obtained, and the corresponding target performance index data is extracted from this data. The content of the target performance index data can be referenced from the aforementioned performance index data, and will not be elaborated upon here.

[0154] Based on the target performance index data, the resource allocation strategy in the target test configuration is optimized to obtain the corresponding target resource allocation strategy.

[0155] In this embodiment, in-depth analysis of the aforementioned target performance metrics data can identify potential performance bottlenecks in the target system. For example, it might be discovered that a certain business module experiences significantly longer response times when processing large amounts of data, or that a component's CPU utilization remains excessively high, leading to a decline in overall system performance. Then, based on the identified performance bottlenecks, the optimization direction for the resource allocation strategy is determined. If a component's CPU utilization is too high, consider increasing its CPU resource allocation; if insufficient network bandwidth causes slow data transmission, consider optimizing the network communication protocol or increasing network bandwidth; if excessive memory usage affects system operation, consider optimizing the memory management strategy or increasing memory resources. Furthermore, according to the determined optimization direction, the resource allocation strategy in the aforementioned target test configuration is adjusted accordingly to generate an optimized target resource allocation strategy. For example, resource allocation parameters in the test script can be modified to allocate more CPU or memory resources to the corresponding components. After adjustment, the simulation test is executed again, recording new performance metrics data to verify whether the optimized target resource allocation strategy effectively improves system performance. If the performance improvement is not significant, the reasons are further analyzed, and the resource allocation strategy is adjusted again until the system performance meets the expected requirements. Optimizing resource allocation strategies aims to improve resource utilization, reduce resource waste, and enhance overall performance of the target system during actual operation.

[0156] Based on the target protocol adaptation parameters and the target resource allocation strategy, a configuration generation process is performed to obtain a connection configuration corresponding to the connection tool.

[0157] In this embodiment, the above configuration generation process includes integrating the target protocol adaptation parameters, which have been adjusted and verified multiple times, with the optimized target resource allocation strategy. The protocol adaptation parameters ensure the compatibility of communication protocols between components and interfaces in the target system, while the resource allocation strategy guarantees the rational utilization and efficient operation of system resources. Furthermore, the integrated target protocol adaptation parameters and target resource allocation strategy are used as the core content of the final connection configuration. Simultaneously, considering factors such as the scalability and security of the target system, the generated initial connection configuration is further improved. Specifically, this is achieved by reserving a certain amount of resource expansion space and setting reasonable security access rules. The final connection configuration is a fully verified and optimized solution that ensures the connection tool can run stably and efficiently when actually deployed to the target system, and achieves perfect compatibility with the connection tool.

[0158] Based on the above processing flow, this application performs simulation testing using a connection tool, analyzes the obtained test data to adjust the corresponding protocol adaptation parameters and resource allocation strategies, and then generates a configuration based on the adjusted target protocol adaptation parameters and target resource allocation strategies. This ensures the efficient and accurate generation of connection configurations corresponding to the connection tool, guaranteeing the accuracy and standardization of the obtained connection configurations. Furthermore, by integrating reasonable settings for protocol adaptation parameters and optimized resource allocation strategies, this application ensures the connection tool can run stably and efficiently during actual system deployment, thereby reducing problems and failures during actual deployment, shortening the system integration deployment cycle, and achieving rapid deployment.

[0159] In some optional implementation methods, this application constructs a comprehensive protection system for data security and system stability: during the interface description parsing process, a strict data filtering and verification mechanism is adopted to ensure the security and accuracy of input data; during the connection tool generation process, multiple verification and testing steps are used to ensure the stability and reliability of the generation tool; during the system integration and deployment phase, a real-time monitoring and early warning mechanism is set up to promptly detect and handle potential problems, ensuring the stable operation of the integrated business system.

[0160] In some alternative implementations, the user information obtained is subject to user consent and complies with relevant laws and policies.

[0161] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing related hardware through computer-readable instructions. These computer-readable instructions can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above methods. The aforementioned storage medium can be a non-volatile storage medium such as a magnetic disk, optical disk, or read-only memory (ROM), or random access memory (RAM).

[0162] It should be understood that although the steps in the flowcharts of the accompanying figures are shown sequentially as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the accompanying figures may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the sub-steps or stages of other steps.

[0163] Further reference Figure 3 As a response to the above Figure 2 To implement the method shown, this application provides an embodiment of a tool generation apparatus, which is similar to... Figure 2 Corresponding to the method embodiments shown, this device can be specifically applied to various electronic devices.

[0164] like Figure 3 As shown, the tool generation device 300 described in this embodiment includes: a first processing module 301, a first generation module 302, a second processing module 303, an adjustment module 304, a second generation module 305, a third processing module 306, a determination module 307, and a deployment module 308. Wherein:

[0165] The first processing module 301 is used to extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information.

[0166] The first generation module 302 is used to perform data generation processing on the key element set based on a preset rule reasoning algorithm to obtain the corresponding interface model.

[0167] The second processing module 303 is used to construct a corresponding call sequence diagram based on the interface model, and to optimize the call sequence diagram to generate a corresponding connection logic framework.

[0168] The adjustment module 304 is used to adjust the exception handling logic in the connection logic framework and generate a corresponding enhanced logic structure.

[0169] The second generation module 305 is used to generate an automated build script based on the enhanced logic structure;

[0170] The third processing module 306 is used to verify the construction script based on a preset verification strategy to obtain the corresponding verification result, and to generate an executable connection tool based on the verification result and the construction script.

[0171] The determination module 307 is used to perform simulation test processing based on the connection tool to obtain corresponding test data, and determine the connection configuration corresponding to the connection tool based on the test data;

[0172] Deployment module 308 is used to deploy the connection tool and the connection configuration to the target system.

[0173] In some optional implementations of this embodiment, the first processing module 301 includes:

[0174] The first judgment submodule is used to scan the interface description text and determine whether there are ambiguous expressions in the interface description text.

[0175] The correction submodule is used to correct the interface description text based on preset semantic supplementation rules if the condition is met, so as to obtain the corrected target interface description text.

[0176] The first processing submodule is used to preprocess and semantically analyze the target interface description text based on a preset natural language processing algorithm in order to identify the corresponding feature information.

[0177] The first extraction submodule is used to classify the feature information based on a preset classification strategy in order to extract the corresponding key information; wherein, the key information includes parameter information and protocol information;

[0178] The second processing submodule is used to integrate and standardize the parameter information and the protocol information to construct the corresponding initial key element set;

[0179] The third processing submodule is used to perform deduplication and standardization processing on the initial key element set to obtain the corresponding first key element set.

[0180] The first verification submodule is used to perform verification processing on the first set of key elements based on a preset verification strategy;

[0181] The first determining submodule is used to use the first key element set as the key element set if the first key element set passes the verification.

[0182] In some optional implementations of this embodiment, the first generation module 302 includes:

[0183] The identification submodule is used to perform format matching on the key element set based on a preset rule reasoning algorithm, so as to identify the correspondence between the key element set and the preset standard template;

[0184] The fourth processing submodule is used to analyze the correspondence. If it is detected that the key element set and the standard template have a format mismatch, the key element set is adjusted according to the preset conversion rules to obtain the corresponding second key element set.

[0185] The first generation submodule is used to generate a temporary mapping relationship corresponding to the standard template by parsing the unknown protocol type based on a preset adaptation rule if an unknown protocol type is detected in the set of key elements.

[0186] The first integration submodule is used to integrate the second set of key elements into a standardized target interface description based on the temporary mapping relationship and the standard template.

[0187] The verification submodule is used to perform consistency verification on the target interface description based on a preset consistency verification strategy.

[0188] The second determining submodule is used to use the target interface description as the interface model if the target interface description passes the consistency check.

[0189] In some optional implementations of this embodiment, the second processing module 303 includes:

[0190] The second extraction submodule is used to parse the interface model to extract the corresponding call order and interface dependency constraints.

[0191] A submodule is constructed to build a corresponding call sequence graph based on the call order and the interface dependency constraints.

[0192] The second generation submodule is used to perform interface analysis on the call sequence graph to obtain the corresponding interface analysis results, and generate the corresponding dynamic call graph based on the interface analysis results;

[0193] The second judgment submodule is used to determine whether there is a circular dependency in the dynamic call graph;

[0194] The first adjustment submodule is used to optimize and adjust the calling order of the dynamic call graph based on a preset adjustment strategy if the dynamic call graph has circular dependencies, so as to obtain the corresponding target dynamic call graph.

[0195] The third judgment submodule is used to determine whether the call sequence corresponding to the target dynamic call graph meets the preset protocol adaptation requirements;

[0196] The third generation submodule is used to perform logical reorganization processing on the call sequence to generate the corresponding connection logic framework if the condition is met.

[0197] In some optional implementations of this embodiment, the adjustment module 304 includes:

[0198] The detection submodule is used to perform integrity detection on the error handling branches in the connection logic framework based on a preset verification matching algorithm.

[0199] The first supplementary submodule is used to supplement the connection logic framework with a predefined rollback path if it is detected that the connection logic framework is missing an exception handling branch, so as to obtain the corresponding first connection logic framework.

[0200] The second verification submodule is used to verify the compatibility between the rollback path and the main logic flow of the first connection logic framework, and obtain the corresponding verification result.

[0201] The second adjustment submodule is used to adjust the exception handling logic in the first connection logic framework if the verification result is that the compatibility verification is not passed, so as to obtain the adjusted second connection logic framework.

[0202] The third verification submodule is used to perform coverage verification on the second connection logic framework based on a preset iterative checking strategy;

[0203] The fourth generation submodule is used to refine the details of the second connection logic framework if the second connection logic framework passes the coverage verification, so as to generate the corresponding enhanced logic structure.

[0204] In some optional implementations of this embodiment, the third processing module 306 includes:

[0205] The second integration submodule is used to integrate the data interaction paths of the construction script to obtain the corresponding first construction script;

[0206] The fourth judgment submodule is used to determine whether the first build script covers all relevant technical standards;

[0207] The third determination submodule is used to determine the missing specified technical standards in the first construction script if the first construction script does not cover all relevant technical standards.

[0208] The second supplementary submodule is used to supplement the first build script with adaptation logic corresponding to the specified technical standard to obtain the corresponding second build script;

[0209] The fourth verification submodule is used to perform executable verification on the second build script;

[0210] The fifth generation submodule is used to generate an executable linker based on the second build script if the second build script passes the execution verification.

[0211] In some optional implementations of this embodiment, the determining module 307 includes:

[0212] The testing submodule is used to perform simulated test processing based on the connection tool and obtain the corresponding execution logs;

[0213] The analysis submodule is used to analyze, based on the execution logs, whether there are any protocol mismatches during the simulation test;

[0214] The fifth processing submodule is used to adjust the protocol adaptation parameters based on the preset specifications to obtain the corresponding target protocol adaptation parameters if there is a protocol mismatch, and to generate the corresponding target test configuration based on the target protocol adaptation parameters.

[0215] The sixth processing submodule is used to repeatedly execute the simulation test using the connection tool based on the target test configuration until the execution log shows that there is no protocol exception, and to obtain the current target performance index data;

[0216] The optimization submodule is used to optimize the resource allocation strategy in the target test configuration based on the target performance index data to obtain the corresponding target resource allocation strategy.

[0217] The sixth generation submodule is used to perform configuration generation processing based on the target protocol adaptation parameters and the target resource allocation strategy to obtain the connection configuration corresponding to the connection tool.

[0218] To address the aforementioned technical problems, embodiments of this application also provide a computer device. Please refer to [link / reference needed]. Figure 4 , Figure 4 This is a basic structural block diagram of the computer device in this embodiment.

[0219] The computer device 4 includes a memory 41, a processor 42, and a network interface 43 that are interconnected via a system bus. It should be noted that only the computer device 4 with components 41-43 is shown in the figure; however, it should be understood that it is not required to implement all the shown components, and more or fewer components can be implemented alternatively. Those skilled in the art will understand that the computer device described here is a device capable of automatically performing numerical calculations and / or information processing according to pre-set or stored instructions, and its hardware includes, but is not limited to, microprocessors, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), embedded devices, etc.

[0220] The computer device can be a desktop computer, laptop, handheld computer, or cloud server, etc. The computer device can interact with the user via a keyboard, mouse, remote control, touchpad, or voice control.

[0221] The memory 41 includes at least one type of readable storage medium, including flash memory, hard disk, multimedia card, card-type memory (e.g., SD or DX memory), random access memory (RAM), static random access memory (SRAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the memory 41 may be an internal storage unit of the computer device 4, such as the hard disk or memory of the computer device 4. In other embodiments, the memory 41 may also be an external storage device of the computer device 4, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 4. Of course, the memory 41 may also include both the internal storage unit and its external storage device of the computer device 4. In this embodiment, the memory 41 is typically used to store the operating system and various application software installed on the computer device 4, such as computer-readable instructions for tool generation methods. In addition, the memory 41 can also be used to temporarily store various types of data that have been output or will be output.

[0222] In some embodiments, the processor 42 may be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip. The processor 42 is typically used to control the overall operation of the computer device 4. In this embodiment, the processor 42 is used to execute computer-readable instructions stored in the memory 41 or to process data, for example, to execute computer-readable instructions of the tool generation method.

[0223] The network interface 43 may include a wireless network interface or a wired network interface, which is typically used to establish communication connections between the computer device 4 and other electronic devices.

[0224] This application also provides another embodiment, namely, providing a computer-readable storage medium storing computer-readable instructions that can be executed by at least one processor to cause the at least one processor to perform the steps of the tool generation method described above.

[0225] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal device (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0226] Obviously, the embodiments described above are only some embodiments of this application, not all embodiments. The accompanying drawings show preferred embodiments of this application, but do not limit the patent scope of this application. This application can be implemented in many different forms; rather, the purpose of providing these embodiments is to provide a more thorough and comprehensive understanding of the disclosure of this application. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing specific embodiments, or make equivalent substitutions for some of the technical features. Any equivalent structures made using the content of this application's specification and drawings, directly or indirectly applied to other related technical fields, are similarly within the scope of patent protection of this application.

Claims

1. A tool generation method, characterized in that, Includes the following steps: Extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information; The key element set is processed by a preset rule-based reasoning algorithm to generate the corresponding interface model. Based on the interface model, a corresponding call sequence diagram is constructed, and the call sequence diagram is optimized to generate a corresponding connection logic framework; The exception handling logic in the connection logic framework is adjusted to generate a corresponding enhanced logic structure. Automated build scripts are generated based on the enhanced logic structure; The build script is verified based on a preset verification strategy to obtain the corresponding verification result, and an executable connection tool is generated based on the verification result and the build script. Based on the connection tool, a simulation test is performed to obtain the corresponding test data, and based on the test data, the connection configuration corresponding to the connection tool is determined. Deploy the connection tool and the connection configuration to the target system; The step of adjusting the exception handling logic in the connection logic framework to generate a corresponding enhanced logic structure specifically includes: Integrity checks are performed on the error handling branches in the connection logic framework based on a preset verification matching algorithm. If an exception handling branch is detected to be missing in the connection logic framework, a predefined rollback path is added to the connection logic framework to obtain the corresponding first connection logic framework. The compatibility of the rollback path with the main logic flow of the first connection logic framework is verified, and the corresponding verification results are obtained. If the verification result is that the compatibility verification fails, the exception handling logic in the first connection logic framework is adjusted to obtain the adjusted second connection logic framework. The second connection logic framework is covered and verified based on a preset iterative checking strategy; If the second connection logic framework passes the coverage verification, then the second connection logic framework is further refined to generate the corresponding enhanced logic structure.

2. The tool generation method according to claim 1, characterized in that, The step of extracting key information from the obtained interface description text corresponding to the target system and generating a corresponding set of key elements based on the key information specifically includes: The interface description text is scanned to determine whether there are any ambiguous expressions in the interface description text; If so, the interface description text is corrected based on preset semantic supplementation rules to obtain the corrected target interface description text; The target interface description text is preprocessed and semantically analyzed based on a preset natural language processing algorithm to identify the corresponding feature information. The feature information is classified based on a preset classification strategy to extract the corresponding key information; wherein, the key information includes parameter information and protocol information. The parameter information and the protocol information are integrated and standardized to construct a corresponding initial set of key elements; The initial set of key elements is deduplicated and standardized to obtain the corresponding first set of key elements. The first set of key elements is verified based on a preset verification strategy. If the first set of key elements passes the verification, then the first set of key elements will be used as the set of key elements.

3. The tool generation method according to claim 1, characterized in that, The step of generating a corresponding interface model by processing the set of key elements using a preset rule-based reasoning algorithm specifically includes: The key element set is format matched based on a preset rule reasoning algorithm to identify the correspondence between the key element set and the preset standard template. If the correspondence is analyzed and a format mismatch is detected between the key element set and the standard template, the key element set is adjusted according to the preset conversion rules to obtain the corresponding second key element set. If an unknown protocol type is detected in the set of key elements, then the unknown protocol type is parsed based on the preset adaptation rules to generate a temporary mapping relationship corresponding to the standard template. Based on the temporary mapping relationship and the standard template, the second set of key elements is integrated into a standardized target interface description; The target interface description is subjected to consistency verification based on a preset consistency verification strategy. If the target interface description passes the consistency check, then the target interface description is used as the interface model.

4. The tool generation method according to claim 1, characterized in that, The step of constructing a corresponding call sequence diagram based on the interface model and optimizing the call sequence diagram to generate a corresponding connection logic framework specifically includes: The interface model is parsed to extract the corresponding call order and interface dependency constraints; Construct a corresponding call sequence diagram based on the call order and the interface dependency constraints; The call sequence graph is analyzed to obtain the corresponding interface analysis results, and a corresponding dynamic call graph is generated based on the interface analysis results. Determine whether the dynamic call graph contains circular dependencies; If the dynamic call graph has circular dependencies, the call order of the dynamic call graph is optimized and adjusted based on a preset adjustment strategy to obtain the corresponding target dynamic call graph. Determine whether the call sequence corresponding to the target dynamic call graph conforms to the preset protocol adaptation requirements; If so, the call sequence is logically reorganized to generate the corresponding connection logic framework.

5. The tool generation method according to claim 1, characterized in that, The step of verifying the build script based on a preset verification strategy to obtain a corresponding verification result, and generating an executable linker based on the verification result and the build script, specifically includes: The data interaction paths of the construction script are integrated to obtain the corresponding first construction script; Determine whether the first build script covers all relevant technical standards; If the first build script does not cover all relevant technical standards, then the specified technical standards that are missing in the first build script are identified. The first build script is supplemented with adaptation logic corresponding to the specified technical standard to obtain the corresponding second build script; Perform execution verification on the second build script; If the second build script passes the execution verification, an executable linker is generated based on the second build script.

6. The tool generation method according to claim 1, characterized in that, The step of performing simulation testing based on the connection tool to obtain corresponding test data, and determining the connection configuration corresponding to the connection tool based on the test data, specifically includes: The simulation test is performed based on the connection tool, and the corresponding execution logs are obtained; Based on the execution logs, analyze whether there are any protocol mismatches during the simulation test; If there is a protocol mismatch, the protocol adaptation parameters are adjusted according to the preset specifications to obtain the corresponding target protocol adaptation parameters, and the corresponding target test configuration is generated based on the target protocol adaptation parameters. Based on the target test configuration, the connection tool is used to repeatedly execute the simulation test until the execution log shows that there are no protocol anomalies and the current target performance index data is obtained; Based on the target performance index data, the resource allocation strategy in the target test configuration is optimized to obtain the corresponding target resource allocation strategy. Based on the target protocol adaptation parameters and the target resource allocation strategy, a configuration generation process is performed to obtain a connection configuration corresponding to the connection tool.

7. A tool generating apparatus, characterized in that, include: The first processing module is used to extract key information from the obtained interface description text corresponding to the target system, and generate a corresponding set of key elements based on the key information. The first generation module is used to perform data generation processing on the key element set based on a preset rule reasoning algorithm to obtain the corresponding interface model. The second processing module is used to construct a corresponding call sequence diagram based on the interface model, and to optimize the call sequence diagram to generate a corresponding connection logic framework. The adjustment module is used to adjust the exception handling logic in the connection logic framework and generate the corresponding enhanced logic structure. The second generation module is used to generate automated build scripts based on the enhanced logic structure; The third processing module is used to verify the construction script based on a preset verification strategy to obtain the corresponding verification result, and to generate an executable connection tool based on the verification result and the construction script. The determination module is used to perform simulation test processing based on the connection tool to obtain corresponding test data, and determine the connection configuration corresponding to the connection tool based on the test data; A deployment module is used to deploy the connection tool and the connection configuration to the target system; The adjustment module includes: The detection submodule is used to perform integrity detection on the error handling branches in the connection logic framework based on a preset verification matching algorithm. The first supplementary submodule is used to supplement the connection logic framework with a predefined rollback path if it is detected that the connection logic framework is missing an exception handling branch, so as to obtain the corresponding first connection logic framework. The second verification submodule is used to verify the compatibility between the rollback path and the main logic flow of the first connection logic framework, and obtain the corresponding verification result. The second adjustment submodule is used to adjust the exception handling logic in the first connection logic framework if the verification result is that the compatibility verification is not passed, so as to obtain the adjusted second connection logic framework. The third verification submodule is used to perform coverage verification on the second connection logic framework based on a preset iterative checking strategy; The fourth generation submodule is used to refine the details of the second connection logic framework if the second connection logic framework passes the coverage verification, so as to generate the corresponding enhanced logic structure.

8. A computer device, characterized in that, The tool includes a memory and a processor, wherein the memory stores computer-readable instructions, and the processor executes the computer-readable instructions to implement the steps of the tool generation method as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-readable instructions, which, when executed by a processor, implement the steps of the tool generation method as described in any one of claims 1 to 6.

Images