Research and development code generation method, storage medium and computer program product

Abstract

The application discloses a research and development code generation method, a storage medium and a computer program product, relates to the technical field of artificial intelligence, and the method comprises the following steps: acquiring a function requirement text sent by a research and development personnel; calling a preset large language model to structurally disassemble the function requirement text, and generating a code design scheme; the code design scheme comprises function point design, database table design and API interface design; a mapping relationship is established among the function point design, the database table design, the API interface design and a preset code project; a code template list is matched based on a function point type in the function point design, placeholders in the code template list are replaced according to the mapping relationship, and a templated code framework is generated; and the templated code framework is completed to obtain research and development code. Through the unified mapping relationship and the code template list, the templated code framework is completed, and the efficiency and accuracy of the research and development code generation are improved.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to the development of code generation methods, storage media, and computer program products. Background Technology

[0002] Traditional R&D coding processes typically rely on manual processes for requirement breakdown, design document writing, and code implementation. However, there's a lack of structured mapping between these three elements. Each information transfer depends on manual understanding and transcription, which is not only labor-intensive but also prone to misunderstandings and transcription errors, leading to long development cycles and high rework rates. Furthermore, different developers often implement the same type of functionality in significantly different ways, lacking unified code templates and standards, resulting in inconsistent code quality.

[0003] Therefore, how to improve the efficiency and accuracy of R&D code generation has become a technical problem that this application urgently needs to solve. Summary of the Invention

[0004] The main purpose of this application is to provide a method for generating R&D code, a storage medium, and a computer program product, aiming to solve the technical problem of how to improve the efficiency and accuracy of R&D code generation.

[0005] To achieve the above objectives, this application proposes a method for generating research and development code, the method comprising: Obtain the functional requirement text sent by the R&D personnel; The pre-defined large language model is invoked to structurally decompose the functional requirement text and generate a code design scheme; the code design scheme includes functional point design, database table design and API interface design; Establish a mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project; Based on the functional point type matching code template list in the functional point design, placeholders in the code template list are replaced according to the mapping relationship to generate a templated code framework. Complete the templated code framework to obtain the development code.

[0006] In one embodiment, the step of obtaining the functional requirement text sent by the R&D personnel further includes: Obtain the system type sent by the R&D personnel; Configure the business suite template according to the system type, and create a standard code project containing the business suite template.

[0007] In one embodiment, the step of calling a preset large language model to structurally decompose the functional requirement text and generate a code design scheme includes: The large language model is invoked to perform semantic parsing on the functional requirement text, and the functional modules corresponding to the functional requirement text are identified. Generate a functional description document for the functional module, and generate functional point designs based on the functional description document; Under the condition that the functional point design has been manually reviewed, the large language model is called based on the functional point design to generate the database table design; Under the condition that the database table design has been manually reviewed, the API interface design is generated by calling the large language model based on the functional point design and the database table design.

[0008] In one embodiment, the step of generating a functional description document for the functional module and generating functional point designs based on the functional description document includes: Determine the function type of the functional module, and generate a corresponding Chinese name and English name for the functional module based on the function type; Generate a structured functional description document based on the results of the semantic parsing; The functional point design is obtained by integrating the functional description document, the Chinese name, the English name, and the functional type.

[0009] In one embodiment, the step of generating the API interface design by calling the large language model based on the function point design and the database table design includes: Under the condition that the design of the aforementioned functional points has been manually reviewed, obtain manually sorted interface information; The functional design is combined with the database table design, and the large language model is called to parse the manually sorted interface information to obtain the API interface design.

[0010] In one embodiment, the step of establishing the mapping relationship between the function point design, the database table design, the API interface design, and the preset code project includes: Extract the Chinese and English names from the design of the aforementioned functional points; Based on the Chinese name and the English name, find the corresponding Chinese name and English name in the API interface design to establish a first mapping relationship between the function point design and the API interface design; By associating the input and output parameters of the API interface design with the database table fields of the database table design, a second mapping relationship between the API interface design and the database table design is obtained; By associating the aforementioned functional design points with the corresponding code projects, a third mapping relationship is obtained; The first mapping relationship, the second mapping relationship, and the third mapping relationship are integrated to obtain the mapping relationship.

[0011] In one embodiment, the step of generating a templated code framework by replacing placeholders in the code template list according to the mapping relationship based on the function point type matching code template list in the function point design includes: Obtain the function type in the function point design, and retrieve a list of matching code templates from a preset code template library according to the function type; Extract the Chinese names, English names, and database table fields from the API interface design and the database table design based on the mapping relationship; The Chinese name, the English name, and the database table field are used as replacement parameters to replace the placeholders in the code template list, thus obtaining a templated code framework.

[0012] In one embodiment, the step of completing the templated code framework to obtain the R&D code includes: Scan the code completion points of the templated code framework, and generate a completion task list based on the completion position identifier and completion content description corresponding to the code completion points; Based on the description of the completion content, the completion task list is divided into standard code completion tasks and business logic completion tasks; If the current completion task is a standard code completion task, then the associated database table design and API interface design are loaded according to the mapping relationship, and the template engine is called to generate the first completion code corresponding to the database table design and the API interface design in batches; If the current completion task is a business logic completion task, then the function point design, the database table design, and the API interface design are loaded according to the mapping relationship to generate a code completion suggestion scheme; The code completion suggestions are visualized to obtain the modification requests from the R&D personnel. Based on the modification requirement instruction, multiple rounds of interactive code completion are executed to obtain the second completed code; The current completion task is completed based on the first completion code and / or the second completion code to obtain the R&D code.

[0013] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the research and development code generation method described above.

[0014] In addition, to achieve the above objectives, this application also provides a computer program product, which includes a computer program that, when executed by a processor, implements the steps of the R&D code generation method described above.

[0015] One or more technical solutions proposed in this application have at least the following technical effects: First, a large language model is used to semantically parse the functional requirements text and generate functional points, database tables, and API interface designs, replacing manual sorting and documentation, and reducing comprehension bias and transcription errors. Next, a mapping relationship is established between functional points, database tables, interfaces, and code projects to ensure a structured correspondence and traceability between design assets and code implementation. Based on functional point types, code templates are matched and placeholders are replaced to generate a code framework, solidifying enterprise architecture standards and avoiding inconsistent code quality due to differences in individual coding habits. Finally, through automated completion of the template framework, the overall efficiency and accuracy of R&D code generation are significantly improved. Attached Figure Description

[0016] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0017] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 This is a flowchart illustrating the first embodiment of the code generation method for the present application. Figure 2 This is a flowchart illustrating the second embodiment of the code generation method for the present application. Figure 3 This is a flowchart illustrating the third embodiment of the code generation method for the present application. Figure 4 This is a schematic diagram of the module structure of the code generation device developed according to an embodiment of this application; Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the R&D code generation method in the embodiments of this application.

[0019] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0020] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0021] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0022] The main solution of this application embodiment is as follows: Obtain the functional requirement text sent by the R&D personnel; call a preset large language model to structurally decompose the functional requirement text and generate a code design scheme; the code design scheme includes functional point design, database table design, and API interface design; establish a mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project; match the functional point type in the functional point design with a code template list, replace the placeholders in the code template list according to the mapping relationship, and generate a templated code framework; complete the templated code framework to obtain the R&D code.

[0023] In this embodiment, for ease of description, the R&D Agent will be used as the execution subject in the following description. The R&D Agent is an intelligent software agent based on a large language model, capable of understanding the R&D context, autonomously planning tasks, generating code through multi-round interactive processes, and possessing context management and task orchestration capabilities.

[0024] This application's embodiments take into account that: traditional R&D coding processes typically rely on manual requirements decomposition, design document writing, and code implementation. However, there is a lack of structured mapping relationships between requirements documents, design documents, and code. Each information transfer depends on manual understanding and transcription, which not only consumes a significant amount of manpower but also easily introduces misunderstandings and transcription errors, resulting in long development cycles and high rework rates. Furthermore, different developers often implement the same type of functionality in significantly different ways, lacking unified code templates and standard constraints, leading to inconsistent code quality.

[0025] Therefore, this application provides a solution. First, it uses a large language model to semantically parse the functional requirement text and generate functional points, database tables, and API interface designs, replacing manual sorting and documentation, and reducing comprehension bias and transcription errors. Second, it establishes a mapping relationship between functional points, database tables, interfaces, and code projects, ensuring a structured correspondence and traceability between design assets and code implementation. Third, it generates a code framework by matching code templates based on functional point types and replacing placeholders, solidifying enterprise architecture standards and avoiding inconsistent code quality due to differences in individual coding habits. Finally, through automated completion of the template framework, it significantly improves the overall efficiency and accuracy of R&D code generation.

[0026] It should be noted that the executing entity in this embodiment can be a computing service device with data processing, network communication, and program execution functions, such as a tablet computer, personal computer, or mobile phone, or an electronic device or research and development intelligent agent capable of performing the above functions. The following description uses a research and development intelligent agent as an example to illustrate this embodiment and the subsequent embodiments.

[0027] Based on this, the embodiments of this application provide a method for generating research and development code, referring to... Figure 1 , Figure 1 This is a flowchart illustrating the first embodiment of the code generation method for this application.

[0028] In this embodiment, the R&D code generation method includes steps S10 to S50: Step S10: Obtain the functional requirement text sent by the R&D personnel; It should be noted that, in this embodiment of the application, the R&D agent provides a requirement input interface. The R&D agent receives functional requirement text in natural language format typed by R&D personnel through this interface, or receives uploaded requirement document files and extracts the functional requirement text from them. The functional requirement text describes the business process, data items, and operation steps of the function to be developed.

[0029] Step S20: Call the preset large language model to perform structured decomposition of the functional requirement text and generate a code design scheme; the code design scheme includes functional point design, database table design and API interface design; It should be noted that, in the embodiments of this application, the preset large language model refers to a large language model that has been pre-trained and fine-tuned, deployed in the background of the R&D intelligent agent or called through the application programming interface. It has the ability to understand semantics, make logical reasoning and generate structured content, and can be one of the models such as GLM-5 or DeepSeek or a combination thereof.

[0030] A code design scheme refers to a set of structured design assets generated before code writing, which includes at least functional point design, database table design, and API interface design.

[0031] Function point design refers to the description of the smallest functional unit obtained after atomically decomposing business requirements, including the functional module affiliation, function type, Chinese name, English naming identifier, and function description document.

[0032] Database table design refers to the definition of the database table structure generated based on business requirements, including table name, field name, field type, field length, default value, whether it is nullable, and index definition.

[0033] API interface design refers to the application interface definition document generated based on function point design and database table design, which includes interface path, HTTP method, input parameter structure, output parameter structure and return code design.

[0034] Specifically, the research and development agent calls a large language model to perform semantic parsing on the functional requirement text, generates a functional point design that includes functional type, English naming identifier and functional description document, and saves it after receiving manual review and confirmation.

[0035] Secondly, after the functional point design is saved, the R&D agent, based on the business description in the functional point design and the preset database design specifications, calls the large language model to generate a database table design draft; the database table design draft becomes effective after being manually reviewed and approved through the review process.

[0036] Finally, after the database table design takes effect, the R&D agent, based on the functional point design and the database table design, calls the large language model to generate an API interface design document; wherein, the prefix of the interface name or method name in the API interface design document is forcibly inherited from the English naming identifier in the functional point design.

[0037] Step S30: Establish the mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project; It should be noted that, in the embodiments of this application, the mapping relationship refers to the set of corresponding association rules established between different design assets and between design assets and code physical storage units, which can be parsed and traced by machines.

[0038] A pre-defined code project refers to a code project entity that has been initialized and orchestrated before code generation is executed. It includes a clear project root directory path, layered package structure definition, and remote address of the code repository.

[0039] Specifically, the English naming identifiers in the functional point design are used as the naming prefixes of the API interface design, establishing a one-to-one correspondence between functional points and API interfaces. Further, based on the table names in the database table design, corresponding persistent object class names and data access layer mapping file names are generated according to preset rules, establishing a mapping from database tables to code objects. Next, based on the functional module identifier to which the functional point design belongs, preset configurations are queried to determine its associated target code project and target code storage path. Finally, based on the API interface design, the corresponding class names and naming conventions of the control layer, facade layer, and request / response objects are derived, establishing a mapping between API interfaces and the code layering structure.

[0040] The mapping relationship data mentioned above is persistently stored in the mapping relationship table. Each mapping record contains the source asset type, source asset identifier, target asset type, target asset identifier, and mapping rule version number, which can be used as the addressing basis and placeholder replacement parameter source in the subsequent code generation stage.

[0041] Step S40: Based on the function point type matching code template list in the function point design, replace the placeholders in the code template list according to the mapping relationship to generate a templated code framework; It should be noted that, in the embodiments of this application, the function point type refers to the type identifier determined for each function point during the function point design phase, and its value is interface type, page type or component type.

[0042] The code template list refers to a collection of one or more code templates associated with a specific functional type in the R&D intelligent agent template library. Each code template is a pre-defined code skeleton file that conforms to the enterprise technology platform layered architecture specifications, and it contains placeholders that can be replaced. The placeholders are wrapped in specific tags.

[0043] A templated code framework refers to a collection of initial code files containing specific identifiers generated after placeholder replacement operations. It does not yet contain specific business logic implementations, but it already has a complete class structure, package references, annotation declarations, and method signatures.

[0044] Specifically, the R&D agent reads the function point type of the functional point design and matches the corresponding code template list in the template library. After receiving the R&D personnel's selection instruction for the target template, the R&D agent loads the mapping relationship and extracts replacement parameters such as interface English names, method names, and table names. Subsequently, the template engine traverses the selected templates, identifies and replaces the placeholders, generates a templated code framework file containing a complete class structure, package references, and method signatures, and writes it to the corresponding directory path of the code project according to the mapping relationship.

[0045] Step S50: Complete the templated code framework to obtain the R&D code.

[0046] Specifically, the R&D agent scans the code content of each file within the templated code framework, identifying code completion markers marked by specific comments or annotations. Each completion marker contains a completion location identifier and a description of the completion content. The R&D agent aggregates all completion markers into a completion task list and, based on keywords and contextual semantics in the completion content description text, completes the code to obtain the final R&D code.

[0047] It should be noted that in this embodiment, the R&D agent must load and comply with preset project-level rule configurations during the process of executing structured decomposition to generate code design schemes and completing templated code frameworks. Specifically, during the task initialization phase, the R&D agent checks whether a CLAUDE.md rule configuration file exists in the root directory of the current code project; if it exists, it parses the rule entries in the CLAUDE.md file. These rule entries include technology stack version constraints, non-standard directory structure mapping relationships, usage specifications for specific dependency libraries, and naming exception rules agreed upon by the team. The R&D agent uses these rule entries as part of the context constraints for the large language model to reference and comply with when generating design documents or code, ensuring that the generated results are consistent with existing project specifications.

[0048] Additionally, it should be noted that this embodiment also supports extending the code generation capabilities of the R&D agent in specific scenarios through a Skill customization system. Specifically, the R&D agent maintains a Skill library, with each Skill stored in a SKILL.md file, containing the skill name, trigger condition expression, and specific instruction content. When the received functional requirement text, completed content description, or instruction entered by the developer matches the trigger condition of a Skill, the R&D agent automatically loads the Skill file and injects the specific instruction content as a temporary context into the model invocation process of the current task. Through the loading of Skills, the R&D agent can produce professional code with a consistent style and conforming to the team's unified standards in specific business scenarios (such as generating data export code conforming to a preset format, implementing templates for connecting to specified third-party interfaces, etc.).

[0049] This embodiment provides a method for generating R&D code. It calls a large language model to perform semantic parsing on functional requirement text and generate functional points, database tables, and API interface designs, replacing manual sorting and documentation work, reducing comprehension bias and transcription errors. Furthermore, it establishes a mapping relationship between functional points, database tables, interfaces, and code projects, ensuring a structured correspondence and traceability between design assets and code implementation. Based on functional point types, it matches code templates and replaces placeholders to generate code frameworks, solidifying enterprise architecture standards and avoiding inconsistent code quality due to differences in individual coding habits. Finally, through automated completion of the templated framework, it significantly improves the overall efficiency and accuracy of R&D code generation.

[0050] Based on the first embodiment of this application, a second embodiment of this application is proposed. In the second embodiment of this application, content that is the same as or similar to that in the first embodiment described above can be referred to the above description and will not be repeated hereafter.

[0051] Based on this, please refer to Figure 2 , Figure 2A schematic flowchart of the second embodiment provided in this application. Figure 2 As shown, before step S10, the R&D code generation method further includes steps S01~S02: Step S01: Obtain the system type sent by the R&D personnel; The R&D agent receives the system type identifier selected by the R&D personnel through the system initialization wizard interface; or, it receives a natural language description input by the R&D personnel and calls a semantic matching model to determine the corresponding system type. The system type is used to characterize the business domain or technical architecture classification of the system to be developed.

[0052] Step S02: Configure the business suite template according to the system type, and create a standard code project containing the business suite template.

[0053] It should be noted that, in this embodiment of the application, the business suite template refers to a pre-defined collection of code assets bound to a specific system type, which includes the standardized business module skeleton, basic tool class library, configuration file template, layered architecture package structure definition and initial dependency description file necessary for that type of system.

[0054] A standard code project refers to a code project entity that is automatically created and initialized in the code repository by the R&D agent based on the business suite template. It has a complete project directory structure, basic framework code and runnable initial state, and follows the preset specification of dividing the project by business module.

[0055] Specifically, the R&D agent, based on the acquired system type identifier, retrieves and extracts a business suite template data package that matches the system type identifier from a pre-defined business suite template library. Further, it calls the application programming interface of the code hosting platform to generate a code repository name using the current system identifier as the namespace or according to pre-defined naming rules, and creates at least one empty code repository instance on the code hosting platform.

[0056] Furthermore, the R&D agent unpacks the business suite template data package, writes the basic framework code files, business module skeleton files, configuration file templates and dependency description files into the code repository instance according to the preset directory structure, creates an initial code baseline in the code repository, and optionally triggers the continuous integration pipeline to perform the first build verification to ensure that the created standard code project is in a compileable and runnable initial state.

[0057] In this embodiment, by obtaining the system type specified by the R&D personnel and automatically matching the corresponding business suite template, the R&D agent can create a code project containing a basic framework and a standardized business module skeleton from end to end on the code hosting platform, which significantly reduces the time cost and technical threshold of system initialization.

[0058] Based on the first and / or second embodiments of this application, a third embodiment of this application is proposed. In this third embodiment, content that is the same as or similar to the above embodiments can be referred to the above description, and will not be repeated hereafter.

[0059] Based on this, please refer to Figure 3 , Figure 3 The flowchart of the third embodiment provided in this application is as follows: Figure 3 As shown, step S20, which involves calling a preset large language model to structurally decompose the functional requirement text and generate a code design scheme, may include steps S21 to S24: Step S21: Call the large language model to perform semantic parsing on the functional requirement text and identify the functional modules corresponding to the functional requirement text; Specifically, the system takes functional requirement text as input and calls the semantic understanding interface of a pre-defined large language model. The functional requirement text is input into the large language model, which extracts the core business objects and operational intentions. Semantic similarity matching is then performed with the business boundary descriptions of each module in the system's pre-defined functional module tree, and the functional module that meets the pre-defined conditions is selected as the recognition result.

[0060] Step S22: Generate a functional description document for the functional module, and generate functional point designs based on the functional description document; The development agent invokes a large language model to generate structured functional description documents based on semantic parsing results; simultaneously, it determines the functional type, which includes interface type, page type, or component type. The development agent generates Chinese names and English naming identifiers conforming to enterprise naming standards, integrating the functional module affiliation, functional type, Chinese name, English naming identifier, and functional description document into a functional point design scheme, which is then persistently stored after manual review and confirmation.

[0061] Step S23: Under the condition that the functional point design has been manually reviewed, the large language model is called based on the functional point design to generate the database table design; Specifically, the R&D agent extracts business descriptions from functional point designs, combines them with pre-defined database design specifications, and uses a large language model to generate a database table design draft. This draft includes table names, field names, field types, nullability, and index definitions. After manual review and approval, the database table design is marked as effective and persistently stored.

[0062] Step S24: Under the condition that the database table design has been manually reviewed, the large language model is called based on the function point design and the database table design to generate the API interface design.

[0063] Specifically, the development agent loads and implements the functional point design and database table design, receives preliminary interface information input by developers, and calls a large language model to generate API interface design documents. During the generation process, the prefix of the interface's English name or method name is forcibly inherited from the English naming identifier in the functional point design, and the interface's input and output parameter fields are automatically linked to the database table fields. After manual review and approval, the API interface design is marked as effective and persistently stored.

[0064] In this embodiment, the functional requirement text is semantically parsed sequentially by calling a large language model to automatically identify the functional module affiliation, generate a structured functional point design, generate a database table design based on the approved functional point design, and further generate an API interface design that is mandatory to correspond to the English naming identifiers of the functional points after the approval takes effect. This eliminates the misunderstanding of requirements and document conversion errors, while establishing an association mapping between functional points, database tables and API interfaces based on identifier inheritance and field tracing, providing a complete, consistent and traceable design data foundation for the subsequent code generation stage.

[0065] In one feasible implementation, step S22 may include steps S221 to S223: Step S221: Determine the function type of the function module, and generate a Chinese name and an English name corresponding to the function module based on the function type; The research and development of an intelligent agent involves using a large language model to perform semantic parsing of functional requirement texts to classify intents, and then determining the functional type based on preset functional type determination rules. The functional types include interface type, page type, and component type.

[0066] The criteria for determination are as follows: if the functional requirement text mainly describes data query, data change, or business processing, and does not include front-end interface interaction description, it is determined to be an interface type; if it includes page layout or user interface interaction description, it is determined to be a page type; if it describes reusable interface controls or logical units, it is determined to be a component type.

[0067] Furthermore, after determining the function type, the R&D agent calls the large language model to generate Chinese function names that conform to the enterprise's naming conventions, as well as English naming identifiers that follow camelCase case and business domain prefix conventions.

[0068] Step S222: Generate a structured functional description document based on the results of the semantic parsing; The development of an intelligent agent involves calling a large language model to generate a structured functional description document based on the semantic parsing results and the identified functional modules, following a preset template. This functional description document includes fields such as functional background, business process overview, preconditions, main execution steps, branch condition processing, post-results, and explanations of abnormal scenarios. The large language model extracts the corresponding descriptive content from the functional requirement text and generates supplementary tags for missing necessary information fields.

[0069] Step S223: Integrate the function description document, the Chinese name, the English name, and the function type to obtain the function point design.

[0070] The research and development intelligent agent integrates the functional description document, the Chinese name, the English name, and the functional type into a functional point design object.

[0071] It should be noted that in the functional point design object, the English naming identifier is marked as a unique mapping key value. After integration, the R&D agent outputs a preview of the functional point design scheme to the R&D personnel interface, and persists it after receiving a review and confirmation instruction.

[0072] In one feasible implementation, step S24 may include steps S241 to S242: Step S241: Under the condition that the functional point design has been manually reviewed, obtain the manually sorted interface information; After detecting that the functional point design has passed the review, the R&D agent provides an interface design auxiliary input area to the R&D personnel's interface. The R&D agent receives preliminary interface information input by the R&D personnel through the interface design auxiliary input area. The preliminary interface information includes the suggested interface path, HTTP method type, summary of main input parameter fields, and summary of output parameter fields.

[0073] Step S242: Design the functional points and associate them with the database table design, and call the large language model to parse the manually sorted interface information to obtain the API interface design.

[0074] The R&D agent loads the approved function point design object, the associated effective database table design data, and manually compiled interface information. The agent integrates this data with a pre-defined API design specification document into a model invocation context, and calls a large language model to generate a detailed API interface design. The generated content includes the interface path, HTTP method, input parameter structure, output parameter structure, and return code definition. During generation, the prefix of the interface's English name or method name is forcibly inherited from the English naming identifier in the function point design to ensure the identifier correspondence between the API interface and the function point. The generated API interface design document becomes effective after manual review and approval.

[0075] Based on the above embodiments of this application, a fourth embodiment of this application is proposed. In this fourth embodiment, content that is the same as or similar to that in the above embodiments can be referred to the above description, and will not be repeated hereafter.

[0076] In this embodiment, step S30, which establishes the mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project, may include steps S31 to S35: Step S31: Extract the Chinese and English names from the functional point design; Understandably, the R&D agent reads key identifier fields from the approved and persistently stored function point design objects, extracting the Chinese function names and English naming identifiers from the function point designs. The English naming identifier is marked as a unique mapping key-value pair for that function point within the system during the function point design generation phase.

[0077] Step S32: Based on the Chinese name and the English name, find the corresponding Chinese name and English name in the API interface design to establish a first mapping relationship between the function point design and the API interface design; Furthermore, during the API interface design generation phase, the R&D agent has mandated that the English naming identifiers in the functional point design be used as the prefix or main part of the English interface name or method name. The R&D agent establishes a one-to-one correspondence between the functional point design and the API interface design by matching the English naming identifiers in the functional point design with the prefixes of the English interface name or method name in the API interface design, and records this correspondence as the first mapping relationship.

[0078] It is understandable that the first mapping relationship also includes the association between the Chinese names of the function points and the Chinese descriptions of the API interfaces.

[0079] Step S33: Associate the input and output parameters of the API interface design with the database table fields of the database table design to obtain a second mapping relationship between the API interface design and the database table design; When generating API interface designs, the R&D agent automatically matches the parameters in the API input parameter structure and the fields in the output parameter structure with the table fields in the associated database table design. The R&D agent establishes a traceable association between the API parameters and the database table fields based on field names, field types, and business semantic similarity, and records this association as a second mapping relationship. This second mapping relationship is used to determine the data flow path in the subsequent code generation phase.

[0080] Step S34: Associate the functional point design with the corresponding code project to obtain the third mapping relationship; The R&D agent obtains the functional module identifier to which the functional point belongs in the design, queries the pre-set association configuration table of functional modules and code projects during the system initialization phase, and determines the target code project identifier and target code storage path corresponding to the functional point. The R&D agent records the correspondence between the functional point identifier, functional module identifier, and target code project identifier as a third mapping relationship.

[0081] Step S35: Integrate the first mapping relationship, the second mapping relationship, and the third mapping relationship to obtain the mapping relationship.

[0082] The research and development agent merges the first, second, and third mapping relationships into a unified mapping relationship dataset, which is then persistently stored in a mapping relationship table. Each mapping record includes the source asset type, source asset identifier, target asset type, target asset identifier, and mapping rule version number. This mapping relationship dataset serves as the unified addressing basis for template placeholder replacement and code file path resolution in the subsequent code generation stage.

[0083] In this embodiment, a first mapping between function points and API interfaces is established by extracting function point identifiers, a second mapping is formed by associating interface parameters with library table fields, and a third mapping is formed by binding function points with code projects. These three types of mappings are integrated into a unified mapping relationship dataset, which establishes a complete structured association and addressing link from business function points to interface definitions, database structures, and code disk paths. This provides a consistent and traceable data foundation for placeholder replacement and automatic file path resolution in the subsequent code generation stage.

[0084] Based on the above embodiments of this application, a fifth embodiment of this application is proposed. In this fifth embodiment, content that is the same as or similar to that in the above embodiments can be referred to the above description, and will not be repeated hereafter.

[0085] In this embodiment, step S40, which generates a templated code framework by replacing placeholders in the code template list based on the function point type matching code template list in the function point design according to the mapping relationship, may include steps S41 to S43: Step S41: Obtain the function type in the function point design, and retrieve a matching code template list from the preset code template library according to the function type; The function type field in the function point design object is read, where the function type can be one of interface type, page type, or component type. The R&D agent uses the function type as a search condition to query all code templates associated with that function type in a preset code template library, and generates and displays a list of code templates.

[0086] It is understood that the code template library stores code skeleton files that conform to the enterprise technology platform layered architecture specifications, and different functional types correspond to different template sets.

[0087] Step S42: Extract the Chinese names, English names, and database table fields from the API interface design and the database table design based on the mapping relationship; Load the mapping relationship dataset. Based on the first mapping relationship, the R&D agent extracts the Chinese description name, English name, and English method name of the interface from the associated API interface design data; based on the second mapping relationship, it extracts the Chinese annotation name, English name, and field name and type of each field from the associated database table design data.

[0088] Step S43: Use the Chinese name, the English name, and the database table field as replacement parameters, and replace the placeholders in the code template list with the replacement parameters to obtain a templated code framework.

[0089] Furthermore, the template engine for developing the intelligent agent traverses the content of the selected code template file, identifying placeholders wrapped in preset markers. The template engine uses the extracted Chinese names, English names, and library / table fields as replacement parameters, and performs a global replacement according to the correspondence rules between placeholder names and replacement parameters.

[0090] For example, the placeholders for the English names of interfaces in the template are replaced with the extracted English names of the interfaces, the placeholders for the table names are replaced with the English names of the database tables, and the placeholders for the fields are replaced with the corresponding database table field names. After the replacement is completed, a set of templated code framework files containing specific identifiers is generated. The templated code framework has a complete class structure, package references, annotation declarations, and method signatures.

[0091] In this embodiment, by using function type-driven template matching, mapping relationship-driven identifier extraction, and placeholder automatic replacement, the function point identifiers, interface definitions, and library table fields produced in the early design stage are accurately mapped to the code skeleton that conforms to the enterprise layered architecture specifications. This automatically generates a templated code framework with a complete structure and unified naming, eliminating the repetitive work of manually writing standard layered code and the problem of inconsistent naming.

[0092] Based on the above embodiments of this application, a sixth embodiment of this application is proposed. In the sixth embodiment of this application, content that is the same as or similar to the above embodiments can be referred to the above description, and will not be repeated hereafter.

[0093] In this embodiment, step S50, which involves completing the templated code framework to obtain the R&D code, may include steps S51 to S57: Step S51: Scan the code completion points of the templated code framework, and generate a completion task list based on the completion position identifier and completion content description corresponding to the code completion points; The research and development agent traverses the contents of each code file within the templated code framework, identifying code completion markers marked by preset comment tags or specific annotations. Each code completion marker includes a completion location identifier and a completion content description text. The completion location identifier uniquely determines the start and end positions of the code block to be completed within the file, and the completion content description text explains the functional logic that should be implemented at that position or the standard code type that should be generated. The research and development agent summarizes all identified code completion markers to generate a completion task list.

[0094] Step S52: Based on the description of the completed content, divide the completion task list into standard code completion tasks and business logic completion tasks; The completion description text of each completion task in the completion task list is subjected to keyword matching and semantic classification. If the completion description involves persistent object attribute definition, data access layer mapping statement, business facade layer interface call skeleton, or control layer parameter validation encapsulation, then the completion task is classified as a standard code completion task.

[0095] If the description of the completed content involves business rule verification, multi-table joint operation, state machine transition or complex data processing flow, then the completion task shall be classified as a business logic completion task.

[0096] Step S53: If the current completion task is a standard code completion task, then load the associated database table design and API interface design according to the mapping relationship, and call the template engine to generate the first completion code corresponding to the database table design and the API interface design in batches. For standard code completion tasks, the R&D agent loads the design data of the effective database table and API interface associated with the function point based on the mapping relationship dataset.

[0097] Specifically, the development team calls a template engine or rule-based code generator to generate attribute fields and accessor methods for persistent object classes based on the field definitions in the database table design. Based on the table structure in the database table design, they generate structured query language mapping statements for the data access layer mapping file. Based on the input / output parameter structure in the API interface design, they generate the call skeleton for the business facade layer implementation class and parameter validation and return value encapsulation code for the control layer methods. The generated code snippets serve as the first completion code, filling in the corresponding completion positions.

[0098] Step S54: If the current completion task is a business logic completion task, then load the function point design, the database table design, and the API interface design according to the mapping relationship, and generate a code completion suggestion scheme; For business logic completion tasks, the development agent initiates agent completion mode. The development agent automatically loads complete context information based on the mapping dataset, including: the function description document in the function point design, the input / output parameter structure definition in the API interface design, the table structure and field definition in the database table design, a snapshot of the current state of existing code, and the rule configuration file in the project root directory. Based on the above context information, the agent generates code completion suggestions.

[0099] Specifically, the agent uses the aforementioned contextual information as the basis for reasoning, calls a large language model to perform semantic understanding and logical planning on the text describing the content to be completed, and generates a code completion suggestion scheme containing specific code implementation steps. The code completion suggestion scheme includes a preview of the code snippet to be generated, a list of files to be modified, and corresponding modification location identifiers.

[0100] Step S55: Visualize the code completion suggestion to obtain the modification requirements from the R&D personnel. The R&D agent outputs a preview of the suggested code completion to the R&D personnel's interface. The preview interface displays the generated code content and the corresponding completion locations. R&D personnel can review the suggested code completion and input modification requests through the interface. These modification requests describe the adjustments required to the suggested solution or any follow-up questions.

[0101] Step S56: Perform multiple rounds of interactive code completion according to the modification requirement instruction to obtain the second completed code; Furthermore, after receiving the modification request instruction, the R&D agent, based on the loaded complete context, iteratively optimizes the code completion suggestion scheme. The R&D agent supports multi-round interaction; developers can input modification request instructions or follow-up questions multiple times. The agent continuously adjusts the code content based on the original context until it meets the R&D expectations. The finally confirmed code content serves as the second completed code.

[0102] Step S57: Complete the current completion task based on the first completion code and / or the second completion code to obtain the R&D code.

[0103] The R&D agent fills the corresponding completion positions with the first and second completion codes, respectively. All completion content is output to the R&D personnel interface, where the R&D personnel can accept, reject, or request intelligent merging for each completion item. After receiving the final confirmation instruction from the R&D personnel, the R&D agent merges the confirmed code content into the templated code framework to form the final R&D code.

[0104] In one feasible implementation, during the development of R&D code, the R&D agent also provides the following auxiliary capabilities: Normal mode rewriting: Select the code segment to be modified, describe the modification requirements in natural language, and the AI ​​performs code refactoring / rewriting; Agent mode rewriting: For complex rewriting scenarios, the agent automatically breaks down the rewriting steps and completes the process step by step through multiple rounds of interaction; Code quality tools: Provide capabilities such as code explanation (understanding existing code logic), code optimization (providing improvement suggestions), comment generation (automatically generating standardized comments), and intelligent suggestions (providing best practice suggestions based on context); Code checkpoints: Automatically save code snapshots before and after each code modification interaction with the AI, supporting version rollback.

[0105] In this embodiment, by automatically scanning the completion points in the templated code framework and distinguishing them into standard code tasks and business logic tasks, the template engine is called to generate layered standard code corresponding to the library, table and interface design in batches for the former, and the complete context such as function description, library, table structure and interface definition is loaded for the latter to accurately complete complex business logic in a multi-round interactive manner. Finally, the two types of completed code are merged into the code framework to realize the hybrid automatic generation of standardized repetitive coding and personalized core logic, which significantly improves the efficiency and quality of R&D coding while ensuring the uniformity of code specifications.

[0106] This application also provides a research and development code generation device, please refer to... Figure 4 The R&D code generation device includes: Module 10 is used to acquire the functional requirement text sent by R&D personnel; The structured decomposition module 20 is used to call a preset large language model to perform structured decomposition of the functional requirement text and generate a code design scheme; the code design scheme includes functional point design, database table design and API interface design; The mapping relationship establishment module 30 is used to establish the mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project; Matching module 40 is used to match the code template list based on the function point type in the function point design, replace the placeholders in the code template list according to the mapping relationship, and generate a templated code framework. The completion module 50 is used to complete the templated code framework to obtain the R&D code.

[0107] The R&D code generation apparatus provided in this application, employing the R&D code generation method in the above embodiments, can solve the technical problem of R&D code generation. Compared with the prior art, the beneficial effects of the R&D code generation apparatus provided in this application are the same as those of the R&D code generation method provided in the above embodiments, and other technical features in the R&D code generation apparatus are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0108] This application provides a research and development code generation device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the research and development code generation method in Embodiment 1 above.

[0109] The following is for reference. Figure 5 The diagram illustrates a structural schematic of a research and development code generation device suitable for implementing embodiments of this application. The research and development code generation device in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Description), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 5 The R&D code generation device shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0110] like Figure 5As shown, the R&D code generation device may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory 1002 or a program loaded from a storage device 1003 into a random access memory 1004. The random access memory 1004 also stores various programs and data required for the operation of the R&D code generation device. The processing unit 1001, the read-only memory 1002, and the random access memory 1004 are interconnected via a bus 1005. An input / output interface 1006 is also connected to the bus. Typically, the following systems can be connected to the input / output interface 1006: input devices 1007 including, for example, a touch screen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 allows the R&D code generation device to communicate wirelessly or wiredly with other devices to exchange data. Although the figure shows an R&D code generation device with various systems, it should be understood that implementation or possession of all the systems shown is not required. More or fewer systems may be implemented alternatively.

[0111] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from read-only memory 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0112] The R&D code generation device provided in this application, employing the R&D code generation method in the above embodiments, can solve the technical problem of R&D code generation. Compared with the prior art, the beneficial effects of the R&D code generation device provided in this application are the same as those of the R&D code generation method provided in the above embodiments, and other technical features in this R&D code generation device are the same as those disclosed in the method of the previous embodiment, and will not be repeated here.

[0113] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0114] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0115] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, which are used to execute the research and development code generation method in the above embodiments.

[0116] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having 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 fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0117] The aforementioned computer-readable storage medium may be included in the R&D code generation device; or it may exist independently and not be assembled into the R&D code generation device.

[0118] The aforementioned computer-readable storage medium carries one or more programs. When these programs are executed by the R&D code generation device, the R&D code generation device performs the following actions: acquires functional requirement text sent by R&D personnel; calls a preset large language model to structurally decompose the functional requirement text, generating a code design scheme; the code design scheme includes functional point design, database table design, and API interface design; establishes a mapping relationship between the functional point design, the database table design, the API interface design, and a preset code project; matches the functional point type in the functional point design to a code template list, replaces placeholders in the code template list according to the mapping relationship, and generates a templated code framework; completes the templated code framework to obtain the R&D code.

[0119] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0120] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0121] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0122] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described R&D code generation method, thereby solving the technical problem of R&D code generation. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the R&D code generation method provided in the above embodiments, and will not be repeated here.

[0123] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the research and development code generation method described above.

[0124] The computer program product provided in this application can solve the technical problem of R&D code generation. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the R&D code generation method provided in the above embodiments, and will not be repeated here.

[0125] The above description is only a part of the embodiments of this application and does not limit the patent scope of this application. All equivalent structural transformations made under the technical concept of this application and using the contents of the specification and drawings of this application, or direct / indirect applications in other related technical fields, are included in the patent protection scope of this application.

Claims

1. A method for generating research and development code, characterized in that, The method for generating R&D code includes: Obtain the functional requirement text sent by the R&D personnel; The pre-defined large language model is invoked to structurally decompose the functional requirement text and generate a code design scheme; the code design scheme includes functional point design, database table design and API interface design; Establish a mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project; Based on the functional point type matching code template list in the functional point design, placeholders in the code template list are replaced according to the mapping relationship to generate a templated code framework. Complete the templated code framework to obtain the development code.

2. The R&D code generation method as described in claim 1, characterized in that, Before the step of obtaining the functional requirement text sent by the R&D personnel, the following also includes: Obtain the system type sent by the R&D personnel; Configure the business suite template according to the system type, and create a standard code project containing the business suite template.

3. The R&D code generation method as described in claim 1, characterized in that, The step of calling a preset large language model to structurally decompose the functional requirement text and generate a code design scheme includes: The large language model is invoked to perform semantic parsing on the functional requirement text, and the functional modules corresponding to the functional requirement text are identified. Generate a functional description document for the functional module, and generate functional point designs based on the functional description document; Under the condition that the functional point design has been manually reviewed, the large language model is called based on the functional point design to generate the database table design; Under the condition that the database table design has been manually reviewed, the API interface design is generated by calling the large language model based on the functional point design and the database table design.

4. The R&D code generation method as described in claim 3, characterized in that, The steps of generating a functional description document for the functional module and generating functional point designs based on the functional description document include: Determine the function type of the functional module, and generate a corresponding Chinese name and English name for the functional module based on the function type; Generate a structured functional description document based on the results of the semantic parsing; The functional point design is obtained by integrating the functional description document, the Chinese name, the English name, and the functional type.

5. The R&D code generation method as described in claim 3, characterized in that, The steps of calling the large language model based on the functional point design and the database table design to generate the API interface design include: Under the condition that the design of the aforementioned functional points has been manually reviewed, obtain manually sorted interface information; The functional design is combined with the database table design, and the large language model is called to parse the manually sorted interface information to obtain the API interface design.

6. The R&D code generation method as described in claim 1, characterized in that, The steps for establishing the mapping relationship between the functional point design, the database table design, the API interface design, and the preset code project include: Extract the Chinese and English names from the design of the aforementioned functional points; Based on the Chinese name and the English name, find the corresponding Chinese name and English name in the API interface design to establish a first mapping relationship between the function point design and the API interface design; By associating the input and output parameters of the API interface design with the database table fields of the database table design, a second mapping relationship between the API interface design and the database table design is obtained; By associating the aforementioned functional design points with the corresponding code projects, a third mapping relationship is obtained; The first mapping relationship, the second mapping relationship, and the third mapping relationship are integrated to obtain the mapping relationship.

7. The R&D code generation method as described in claim 1, characterized in that, The step of generating a templated code framework by replacing placeholders in the code template list according to the mapping relationship based on the function point type matching code template list in the function point design includes: Obtain the function type in the function point design, and retrieve the matching code template list from the preset code template library according to the function type; Extract the Chinese names, English names, and database table fields from the API interface design and the database table design based on the mapping relationship; The Chinese name, the English name, and the database table field are used as replacement parameters to replace the placeholders in the code template list, thus obtaining a templated code framework.

8. The R&D code generation method as described in claim 1, characterized in that, The steps to complete the templated code framework and obtain the development code include: Scan the code completion points of the templated code framework, and generate a completion task list based on the completion location identifier and completion content description corresponding to the code completion points; Based on the description of the completion content, the completion task list is divided into standard code completion tasks and business logic completion tasks; If the current completion task is a standard code completion task, then the associated database table design and API interface design are loaded according to the mapping relationship, and the template engine is called to generate the first completion code corresponding to the database table design and the API interface design in batches; If the current completion task is a business logic completion task, then the function point design, the database table design, and the API interface design are loaded according to the mapping relationship to generate a code completion suggestion scheme; The code completion suggestions are visualized to obtain the modification requests from the R&D personnel. Based on the modification requirement instruction, multiple rounds of interactive code completion are executed to obtain the second completed code; The current completion task is completed based on the first completion code and / or the second completion code to obtain the R&D code.

9. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the research and development code generation method as described in any one of claims 1 to 8.

10. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the steps of the research and development code generation method as described in any one of claims 1 to 8.

Images