Automatic development method and device based on shared table, equipment and storage medium

Abstract

The invention discloses an automatic development method and device based on a shared table, equipment and a storage medium. The method comprises the steps that at least one piece of interface information in a shared table is obtained, and the shared table comprises interface information filled by a first user of a plurality of systems; and generating a production script based on the interface information and a preset production script template under the condition that an operation of modifying the second version timestamp by a second user is received. Unification of configuration information of related interfaces of system codes is guaranteed, misunderstanding of communication of the systems due to configuration information differences is avoided, and correctness of production scripts is guaranteed.

Description

Technical Field

[0001] This invention relates to the field of automated development technology, and in particular to an automated development method, apparatus, device, and storage medium based on shared tables. Background Technology

[0002] As online banking services continue to grow, banks need to handle increasingly complex customer scenarios, with a growing number and diverse customer base. To meet increasingly stringent regulatory requirements and control financial risks, online banking products generally do not allow users to directly request the bank's back-end systems. Instead, they strictly control the network scope exposed by each back-end system and allow only one specific method of request. This mechanism typically includes a mobile gateway, a set of servers responsible only for handling external requests and responses without processing actual banking transactions, and a back-end gateway for these servers to request the actual bank's back-end systems. Furthermore, to facilitate the analysis of user behavior and the management of these requests, banks usually also build interface management and transaction analysis systems. Therefore, network requests from online banking products are not a simple two-machine interaction process but require the coordinated operation of an entire system.

[0003] However, to ensure that each system can correctly handle user requests and accurately track user behavior and manage requests, each production deployment requires changes not only to the client and corresponding backend, but also to all systems involved in the request chain to handle the updated request logic. Therefore, each deployment necessitates writing different deployment scripts for different systems, which would be an enormous workload if done manually. Furthermore, due to design differences, request and return parameters are often completely inconsistent across systems, resulting in entirely different representations of the same interface request across different systems. This increases communication costs for those responsible for different systems and necessitates regular maintenance of documentation to ensure effective communication. Finally, during the development phase, developers of each system must also save the representation of each interface in their code or documentation. When related systems are updated, developers of each system must also update the corresponding representation in their respective systems. Failure to update in a timely manner can easily lead to system call errors during development, significantly impacting development and integration efficiency. Summary of the Invention

[0004] This invention provides an automated development method, apparatus, device, and storage medium based on shared tables to solve the problem of low development efficiency.

[0005] According to one aspect of the present invention, an automated development apparatus based on a shared table is provided, characterized in that it comprises:

[0006] An interface information acquisition module is used to acquire at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems;

[0007] The production script generation module is used to generate a production script based on the interface information and a preset production script template when a second user modifies the timestamp of the second version.

[0008] According to another aspect of the present invention, an automated development apparatus based on a shared table is provided, characterized in that it comprises:

[0009] An interface information acquisition module is used to acquire at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems;

[0010] The production script generation module is used to generate a production script based on the interface information and a preset production script template when a second user modifies the timestamp of the second version.

[0011] According to another aspect of the present invention, an electronic device is provided, the electronic device comprising:

[0012] At least one processor; and

[0013] A memory communicatively connected to the at least one processor; wherein,

[0014] The memory stores a computer program that can be executed by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the automated development method based on shared tables as described in any embodiment of the present invention.

[0015] According to another aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions for causing a processor to execute and implement the automated development method based on a shared table as described in any embodiment of the present invention.

[0016] The technical solution of this invention obtains at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems; effectively reducing additional communication costs caused by writing documentation, etc.; upon receiving a second user's modification of the second version timestamp, a production script is generated based on the interface information and a preset production script template. This solves the problem of low development efficiency, achieving automated code generation and production script construction based on configuration, effectively shortening configuration time, ensuring the uniformity of interface configuration information related to the code of each system, ensuring that communication between systems is not misunderstood due to differences in configuration information, and guaranteeing the correctness of the production script.

[0017] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of the present invention, nor is it intended to limit the scope of the invention. Other features of the invention will become readily apparent from the following description. Attached Figure Description

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

[0019] Figure 1 This is a flowchart of an automated development method based on a shared table according to Embodiment 1 of the present invention;

[0020] Figure 2a This is a flowchart of an automated development method based on a shared table according to Embodiment 2 of the present invention;

[0021] Figure 2b This is a schematic diagram of a system architecture for an automated development method based on a shared table, according to Embodiment 2 of the present invention.

[0022] Figure 3 This is a schematic diagram of the structure of an automated development method device based on a shared table according to Embodiment 3 of the present invention;

[0023] Figure 4 This is a schematic diagram of the structure of an electronic device that implements the automated development method based on shared tables according to embodiments of the present invention. Detailed Implementation

[0024] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0025] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0026] Example 1

[0027] Figure 1 This is a flowchart illustrating an automated development method based on a shared table, as provided in Embodiment 1 of the present invention. This embodiment is applicable to automated development scenarios. The method can be executed by an automated development device based on a shared table, which can be implemented in hardware and / or software and can be configured in an electronic device. Figure 1 As shown, the method includes:

[0028] S110. Obtain at least one interface information from a shared table, wherein the shared table contains interface information filled in by the first user of multiple systems.

[0029] In this context, shared tables can be understood as online data storage tools for multi-user collaboration, supporting simultaneous editing, viewing, and updating of data by multiple users. Interface information can be understood as information describing the interaction interfaces between systems, such as the interface URL (address), request method, request parameters (required / optional, data type), authentication method, return value format, timeout, and retry strategy. The first user can be understood as the role responsible for filling in and maintaining the interface information, such as developers, testers, or interface providers for each system.

[0030] Specifically, developers of each system enter the interface details of their system into a shared spreadsheet (e.g., for an order system, enter the order query interface). The data format must conform to a preset template (e.g., column names are fixed as "interface name," "URL," "parameters," etc.). The spreadsheet saves all modifications in real time and records version timestamps. Secondary users (or automated systems) can obtain the latest data at any time.

[0031] Optionally, this embodiment provides a tool for maintaining interface information of various related systems based on a shared spreadsheet. This tool comprises two parts: a spreadsheet editor that allows multiple users to edit online, and a spreadsheet containing access control. The spreadsheet contains two tabs: an interface information table and a control table. The interface information table can be directly edited by the responsible personnel of each related system who log in to the spreadsheet editor using pre-provided accounts. Because the spreadsheet is shared, others can immediately see the latest content after each user modifies the table. However, to avoid invalid or illegal triggering of automatic code updates, user edits to the interface information table do not immediately trigger updates; instead, updates are completed through the control table.

[0032] S120. Upon receiving a second user's operation to modify the second version timestamp, a production script is generated based on the interface information and the preset production script template.

[0033] In this context, the second user can be understood as a role responsible for operating production-related processes within the system, such as an administrator. A version timestamp can be understood as an identifier (such as a timestamp or version number) that records the last modification time of a shared table. A production script can be understood as an automated script used to deploy the system or interface to the production environment, including configuration files, command-line instructions, and interface call code.

[0034] Specifically, when operations personnel click the "Generate Script" button, the system automatically modifies the timestamp and starts the process. The system extracts detailed information for at least one interface from a shared table. Filtering by conditions is supported (e.g., reading only interfaces from specific systems). The system then substitutes the interface information into a preset deployment script template. The generated script is saved to a specified directory.

[0035] Optionally, the control table mentioned above contains two timestamps: a table version timestamp and a production version timestamp, and can only be modified by the administrator. After the administrator has reviewed the table, they change the table version timestamp to the current time, which triggers automatic code generation and updates. Furthermore, before each production deployment, the administrator changes the production version timestamp to the pre-production time, which triggers the generation of the production script.

[0036] Optionally, the second version timestamp includes the production version timestamp.

[0037] The production version timestamp can be understood as recording the generation or deployment time of the production script.

[0038] Optionally, receiving the second user's modification of the second version timestamp operation includes:

[0039] The second user is authenticated, and if the second user passes the authentication, the operation of the second user modifying the second version timestamp is received.

[0040] Specifically, the system checks the user's login status and performs authentication. If the user is successfully authenticated, the system queries the user's role and checks if that role has the permission to "modify the production version timestamp". If successful, the operation is allowed to continue; otherwise, an error message (such as "Permission denied") is returned.

[0041] The technical solution of this invention obtains at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems; effectively reducing additional communication costs caused by writing documentation, etc.; upon receiving a second user's modification of the second version timestamp, a production script is generated based on the interface information and a preset production script template. This solves the problem of low development efficiency, achieving automated code generation and production script construction based on configuration, effectively shortening configuration time, ensuring the uniformity of interface configuration information related to the code of each system, ensuring that communication between systems is not misunderstood due to differences in configuration information, and guaranteeing the correctness of the production script.

[0042] Example 2

[0043] Figure 2a This is a flowchart of an automated development method based on a shared table, provided in Embodiment 2 of the present invention. This embodiment is a further optimization of the above embodiment. Optionally, the method further includes: upon receiving a second user's modification of the first version timestamp, for each system, generating target project code based on the interface information and a preset code template corresponding to the interface information, and generating a target project engineering file based on the target project code.

[0044] like Figure 2a As shown, the method includes:

[0045] S210. Obtain at least one interface information from a shared table, wherein the shared table contains interface information filled in by the first user of multiple systems.

[0046] S220. Upon receiving a second user's operation to modify the second version timestamp, a production script is generated based on the interface information and the preset production script template.

[0047] S230. Upon receiving a second user's operation to modify the timestamp of the first version, for each system, generate target project code based on the interface information and the preset code template corresponding to the interface information, and generate target project project files based on the target project code.

[0048] Here, the first version timestamp can be understood as an identifier recording the last change time of the interface information, including table version timestamps. The system refers to the independent business module or subsystem participating in the collaboration. The preset code template can be understood as a code framework pre-written based on the interface information structure, containing variable parts (represented by placeholders or variables) and fixed parts (such as request library calls and error handling logic). The target project code can be understood as code files generated based on the interface information and the preset template, which can be directly compiled or run, typically containing interface call logic, data model definitions, etc. The target project project files can be understood as the configuration files and directories required to organize the target project code into a deployable project structure.

[0049] Specifically, the second user confirms the changes in the system and manually or automatically triggers a timestamp modification operation (e.g., clicking the "Confirm Update" button). The interface information is marked as changed, requiring the generation of related code. All systems requiring code generation (e.g., order system, payment system) are read from the configuration file. Each system is traversed, and all interface information it depends on is queried from a shared table or database (e.g., "Query Order Interface" and "Create Order Interface" for the order system). The target project code is generated. The corresponding code template is selected based on the interface type. The interface information (URL, parameters, methods, etc.) is substituted into the template placeholders to generate the specific code. The generated code is written to the specified directory. Based on the system type (e.g., selecting a predefined project structure template), the generated code files are added to the project directory; dependencies are configured; build parameters are set to generate project files, a directory structure is generated, and the code files are placed.

[0050] Optionally, generating target project code based on the interface information and a preset code template corresponding to the interface information includes: determining a target system associated with the interface information; obtaining a preset code template corresponding to the target system from a pre-established code library; extracting target fields from the interface information using a code generator; and generating the target project code based on the target fields and the preset code template.

[0051] The preset code templates can be understood as the template code and deployment script code that developers of each related system can configure for each system through the code template maintenance function. The target system can be understood as the business system or technology stack to which the interface belongs (such as "user service" or "order service"), used to select the matching code template. The code generator can be understood as a tool or program responsible for parsing interface information, extracting fields, and generating target code based on the template.

[0052] Specifically, developers of each related system can configure template code and deployment script code for each system through the code template maintenance function. When an administrator triggers a code update or deployment script generation, the generator reads and analyzes the information of each interface in the interface information table of the spreadsheet and extracts the corresponding fields. Subsequently, the generator reads the template code of each related system, inserts the extracted interface information according to the template, generates the corresponding project code for the corresponding system, and then inserts it into the corresponding project file through anchor points.

[0053] Optionally, this embodiment provides a service for converting spreadsheet content into configurable code generation and production script generation in different programming languages. This service comprises two parts: a code template maintenance function and a code generator. Developers of each associated system can configure template code and production script code for each system within the code template maintenance function. When an administrator triggers a code update or production script generation, the generator reads and analyzes the information of each interface in the interface information table of the spreadsheet and extracts the corresponding fields. Subsequently, the generator reads the template code of each associated system, inserts the extracted interface information according to the template, generates the corresponding project code for that system, and then inserts it into the corresponding project file via anchor points.

[0054] Optionally, if the template includes the interface field names for all associated systems, the project team developers can immediately retrieve the corresponding interface name from the code after each spreadsheet update. This code can then correctly call the updated interface, reducing both development time and communication costs. Before production deployment, after the administrator triggers the production script generation, the generator reads the production script template code for each associated system and inserts the interface information according to the template, thereby generating the final production script.

[0055] Optionally, determining the target project engineering file based on the target project code includes:

[0056] The interface call location is determined based on the preset anchor point in the project engineering file, and the target project code is inserted into the project engineering file based on the interface call location to obtain the target project engineering file.

[0057] The target project code can be understood as code snippets generated by a code generator based on interface information and templates. The project engineering file can be understood as a structured collection of files for the target project, containing project configuration and existing code. Preset anchor points can be understood as pre-marked insertion positions in the project engineering file, used to locate the target area for code generation.

[0058] Specifically, the process scans the file content, locates predefined anchor point markers, and determines the insertion position based on the interface function (e.g., "Create Order") or code context. The generated target code replaces the anchor point area content or is appended after the anchor point. The modified project file is then saved, creating a complete and usable project structure.

[0059] Optional, also includes:

[0060] If the first user is detected to have modified the target project code, the modified target project code is parsed to obtain the modified interface information;

[0061] The shared table is updated based on the modified interface information.

[0062] The modified target project code can be understood as a version of the original generated code that the user has adjusted, which may include added, deleted, or modified content. The modified interface information can be understood as interface metadata parsed from the modified code, such as paths, parameters, method names, etc., and may include user-defined extended information.

[0063] Specifically, the code generation tool detects changes when users save files, submit changes, or trigger changes via plugins. It monitors file system changes, compares the current code with the original generated code, and determines if the modifications involve interface-related parts, such as method signatures, annotations, and paths. It then uses a code parser to extract the interface information. The tool identifies user-added metadata, such as custom annotations and tags in comments, connects to shared tables, or writes it directly to files, merging the modified interface information with the original data (avoiding overwriting other fields). Finally, it notifies other users that the interface definition has been updated via a pre-defined notification method, such as email.

[0064] Optionally, the modification history and the first user who made the modification can be recorded in the shared table. If the shared table has been modified by another first user, the original first user can be prompted to resolve conflicts, such as merging differences or forcibly overwriting.

[0065] Optionally, it supports reverse engineering code from a shared table, such as automatically regenerating client-side call code after the table is updated. It can also restrict the first user's modification permissions, such as allowing only annotations but disallowing path modification.

[0066] Optionally, this embodiment of the invention provides an interface information update service. This service consists of two parts: code repository configuration management and a static code parsing tool. Developers of each associated system first maintain code repository configuration information in the interface information update service, associating projects with the corresponding code repositories. Furthermore, the system supports code anchor configuration, allowing developers to configure the location of interface call code through anchor points. When a developer submits code to the code repository, the static code parsing tool is triggered and parses the corresponding interface call code in the anchor location code. This code parsing tool supports multiple programming languages, and developers can configure code parsing rules for each project. After the interface information is parsed, the service automatically updates the interface information in the shared spreadsheet, ensuring that the interface information is always up-to-date and eliminating the need for manual maintenance by developers after interface code development.

[0067] Figure 2b This is a schematic diagram of the system architecture of an automated development method based on a shared table, as provided in Embodiment 2 of the present invention. Figure 2b As shown, developers of each associated system maintain their own project code paths and generated code insertion point information (code anchors) in the interface information update service. When interface information is modified, the interface information update service automatically parses the code and pushes the updated interface information to the interface information table. Developers of each system can also manually edit interface information using a table editor. The shared table administrator verifies the interface information table and triggers an update in the control table. After the update is triggered, the code generation service generates the code for each associated system and generates the corresponding production script. The associated system code is automatically inserted into the pre-configured insertion points.

[0068] For example, in the initial state, the client, front-end server, and back-end all only have a repayment interface. The client, front-end server, and back-end configure the Anchor1 anchor point in the update push service and also configure the Anchor1 anchor point in their code. The three related systems also configure template code in the code generator and configure template code for configuring the database update script.

[0069] For example, after the authorized code development is completed, the developers of the three related systems each add the corresponding interface information to the interface information table and notify the administrator to update it. After the administrator approves, he modifies the table version timestamp, which triggers code generation. Subsequently, the code generator generates the related system code according to the pre-configured template code and automatically distributes it to the Anchor1 anchor point of each code file, completing the automatic code update.

[0070] For example, when a developer in a related system modifies code in the Anchor1 code area, the developer pushes the code to the code repository. At this point, the interface information update service receives the push information from the code repository and launches a static code analysis tool to analyze the modified interface information. Subsequently, the interface information update service pushes the updated information to the interface configuration table and updates the shared spreadsheet, allowing developers in other related systems to see the updated interface information. Before production deployment, the administrator reviews the spreadsheet again and modifies the production version timestamp, triggering the generation of the production script. The code generator then generates the production script according to the pre-configured template code and configures the database update script.

[0071] The technical solution of this invention, upon receiving a second user's modification of the first version's timestamp, generates target project code for each system based on the interface information and a preset code template corresponding to the interface information, and then generates target project engineering files based on the target project code. Generating independent code for each system adapts to the data models and interface requirements of different services in a microservice architecture, ensuring inter-system compatibility. Automated generation of engineering files simplifies the deployment process; combined with version information tracked by timestamps, it enables rapid rollback and problem localization, thereby improving overall development efficiency and system reliability.

[0072] Example 3

[0073] Figure 3 This is a schematic diagram of an automated development device based on a shared table, provided in Embodiment 3 of the present invention. Figure 3 As shown, the device includes: an interface information acquisition module 310 and a production script generation module 320.

[0074] The interface information acquisition module 310 is used to acquire at least one interface information in a shared table, wherein the shared table contains interface information filled in by the first user of multiple systems; the production script generation module 320 is used to generate a production script based on the interface information and a preset production script template when a second user modifies the second version timestamp.

[0075] The technical solution of this invention obtains at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems; effectively reducing additional communication costs caused by writing documentation, etc.; upon receiving a second user's modification of the second version timestamp, a production script is generated based on the interface information and a preset production script template. This solves the problem of low development efficiency, achieving automated code generation and production script construction based on configuration, effectively shortening configuration time, ensuring the uniformity of interface configuration information related to the code of each system, ensuring that communication between systems is not misunderstood due to differences in configuration information, and guaranteeing the correctness of the production script.

[0076] Optionally, the device further includes:

[0077] The file generation module is used to generate target project code for each system based on the interface information and the preset code template corresponding to the interface information when a second user modifies the timestamp of the first version, and to generate target project project files based on the target project code.

[0078] Optionally, the device further includes:

[0079] The code parsing module is used to parse the modified target project code when the first user is detected to have modified the target project code, so as to obtain the modified interface information.

[0080] The table update module is used to update the shared table based on the modified interface information.

[0081] Optionally, the file generation module includes:

[0082] The code template acquisition unit is used to determine the target system associated with the interface information and acquire the preset code template corresponding to the target system from the pre-established code library;

[0083] The target code generation unit is used to extract the target fields of the interface information through a code generator, and generate the target project code based on the target fields and the preset code template.

[0084] Optionally, the file generation module is specifically used for:

[0085] The interface call location is determined based on the preset anchor point in the project engineering file, and the target project code is inserted into the project engineering file based on the interface call location to obtain the target project engineering file.

[0086] Optionally, the second version timestamp includes the production version timestamp.

[0087] Optionally, the production script generation module is specifically used for:

[0088] The second user is authenticated, and if the second user passes the authentication, the operation of the second user modifying the second version timestamp is received.

[0089] The automated development apparatus based on shared tables provided in this embodiment of the invention can execute the automated development method based on shared tables provided in any embodiment of the invention, and has the corresponding functional modules and beneficial effects of the method execution.

[0090] Example 4

[0091] Figure 4 A schematic diagram of an electronic device 10 that can be used to implement embodiments of the present invention is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the invention described and / or claimed herein.

[0092] like Figure 4 As shown, the electronic device 10 includes at least one processor 11 and a memory, such as a read-only memory (ROM) 12 or a random access memory (RAM) 13, communicatively connected to the at least one processor 11. The memory stores computer programs executable by the at least one processor. The processor 11 can perform various appropriate actions and processes based on the computer program stored in the ROM 12 or loaded from storage unit 18 into the RAM 13. The RAM 13 may also store various programs and data required for the operation of the electronic device 10. The processor 11, ROM 12, and RAM 13 are interconnected via a bus 14. An input / output (I / O) interface 15 is also connected to the bus 14.

[0093] Multiple components in electronic device 10 are connected to I / O interface 15, including: input unit 16, such as keyboard, mouse, etc.; output unit 17, such as various types of displays, speakers, etc.; storage unit 18, such as disk, optical disk, etc.; and communication unit 19, such as network card, modem, wireless transceiver, etc. Communication unit 19 allows electronic device 10 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0094] Processor 11 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. Processor 11 performs the various methods and processes described above, such as the automated development based on shared tables.

[0095] In some embodiments, the method for automated development based on shared tables can be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program can be loaded and / or mounted on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the method for automated development based on shared tables described above can be performed. Alternatively, in other embodiments, processor 11 can be configured to perform the method for automated development based on shared tables by any other suitable means (e.g., by means of firmware).

[0096] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0097] Computer programs used to implement the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0098] In the context of this invention, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination thereof. Alternatively, a computer-readable storage medium may be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof.

[0099] To provide interaction with a service recipient, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the service recipient; and a keyboard and pointing device (e.g., a mouse or trackball) through which the service recipient can provide input to the electronic device. Other types of devices can also be used to provide interaction with the service recipient; for example, feedback provided to the service recipient can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the service recipient can be received in any form (including voice input, speech input, or tactile input).

[0100] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., service-seeking computers with a graphical service-seeking interface or a web browser through which the service-seeking party can interact with the implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0101] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS services, such as high management difficulty and weak business scalability.

[0102] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0103] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. An automated development method based on shared tables, characterized in that, include: Obtain at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems; Upon receiving a second user's operation to modify the second version's timestamp, a production script is generated based on the interface information and a preset production script template.

2. The method according to claim 1, characterized in that, Also includes: Upon receiving a second user's modification of the first version's timestamp, for each system, target project code is generated based on the interface information and the preset code template corresponding to the interface information, and target project engineering files are generated based on the target project code.

3. The method according to claim 2, characterized in that, Also includes: If the first user is detected to have modified the target project code, the modified target project code is parsed to obtain the modified interface information; The shared table is updated based on the modified interface information.

4. The method according to claim 2, characterized in that, The process of generating target project code based on the interface information and a preset code template corresponding to the interface information includes: Identify the target system associated with the interface information, and obtain the preset code template corresponding to the target system from the pre-established code library; The target fields of the interface information are extracted by the code generator, and the target project code is generated based on the target fields and the preset code template.

5. The method according to claim 2, characterized in that, The step of determining the target project engineering file based on the target project code includes: The interface call location is determined based on the preset anchor point in the project engineering file, and the target project code is inserted into the project engineering file based on the interface call location to obtain the target project engineering file.

6. The method according to claim 1, characterized in that, The second version timestamp includes the production version timestamp.

7. The method according to claim 1, characterized in that, The receipt of the second user's modification of the second version timestamp includes: The second user is authenticated, and if the second user passes the authentication, the operation of the second user modifying the second version timestamp is received.

8. An automated development device based on shared tables, characterized in that, include: An interface information acquisition module is used to acquire at least one interface information from a shared table, wherein the shared table contains interface information filled in by a first user from multiple systems; The production script generation module is used to generate a production script based on the interface information and a preset production script template when a second user modifies the timestamp of the second version.

9. An electronic device, characterized in that, include: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores a computer program that can be executed by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the automated development method based on a shared table as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that cause a processor to execute the automated development method based on a shared table as described in any one of claims 1-7.

Images