Software engineering implementation method

Abstract

The invention discloses a software engineering implementation method, and the method comprises the steps: business modeling: anchoring a demand source, and converting a business demand into a landing model; the software requirement specification specification is used for solidifying a requirement standard and forming a specification document based on the business modeling result; summary design: constructing a technical framework, joining demands and development, and macroscopically planning a system architecture; the framework is converted into an executable scheme, and coverage integration, implementation and development are achieved. According to the software engineering implementation process, a standardized'business modeling driving type 'specification is taken as a core, a five-level process model and a data model are used for constructing a business architecture core framework, full-link connection of'business demand-data logic-IT design-landing implementation' is broken through by means of a structured view, and complex processes / functions are deconstructed and split into micro-service interface-level granularity, micro-service interface-level granularity, micro-service interface-level granularity and micro-service interface-level granularity. Accurate correspondence and decoupling of the service component and the IT component are achieved, and finally efficient landing of the service architecture in the IT architecture is guaranteed.

Description

Technical Field

[0001] This invention relates to the field of software design and development processes, and more particularly to a software engineering implementation method. Background Technology

[0002] Traditional software design and development processes adopt a linear transformation model of "requirements specification → preliminary design", focusing on a single link and lacking a structured connection across the entire chain. This leads to a disconnect between business processes, data logic and IT design, resulting in a high deviation rate in requirement implementation and frequent rework in the later stages.

[0003] Traditional processes employ a linear transformation model of "requirements specification → preliminary design," focusing on only a single stage and failing to establish a structured, end-to-end linkage mechanism from business to IT. This leads to isolated design stages (e.g., business requirements are disconnected from data models and IT implementation), preventing the formation of a complete design loop. Traditional processes also fail to bind business processes and data logic with IT design, pushing development solely from a technical perspective. This results in discrepancies between "what the business needs" and "what IT does" (e.g., business processes are not translated into corresponding system processes, and data logic is not mapped to IT data models), ultimately leading to a disconnect between business logic and IT implementation. Furthermore, traditional processes lack an architectural asset accumulation mechanism, failing to structure and reuse design deliverables such as business components, data models, and IT services. This results in the need to repeatedly develop similar functions in different projects or iterations ("reinventing the wheel"), wasting resources and making it difficult to ensure component consistency. Summary of the Invention

[0004] In view of the above problems, the present invention is proposed to provide a software engineering implementation method that overcomes or at least partially solves the above problems.

[0005] According to one aspect of the present invention, a software engineering implementation method is provided, the implementation method comprising:

[0006] Business modeling: Identify the source of requirements and transform business needs into actionable models;

[0007] Software Requirements Specification: This document formalizes the requirements standards and forms a standardized document based on the business modeling results.

[0008] High-level design: Establish the technical framework, connect requirements and development, and plan the system architecture from a macro perspective;

[0009] Transform the framework into an executable solution, covering integration, implementation, and development.

[0010] Optionally, the business modeling: anchoring to the source of demand and transforming business requirements into a feasible model specifically includes:

[0011] Process modeling: Analyze the core business scenarios, use flowchart tools to define process nodes, flow logic and related roles, and clarify the input / output conditions of each node;

[0012] Data modeling: Based on business processes, identify core data entities, define entity attributes, data types, and relationships between entities, and output ER diagrams;

[0013] User experience modeling: Design interface prototypes based on target user roles to ensure that the prototypes match the business processes;

[0014] Business function analysis: Decompose business objectives, transform process nodes into specific business functions, and form a function list and a mapping relationship table between functions and processes.

[0015] Optionally, the software requirements specification document: solidifies the requirements standards, and is a standardized document formed based on the business modeling results, specifically including:

[0016] Business requirements: Refer to the feature list and explain the business value and application scenarios of each feature;

[0017] Non-functional requirements: Define system security, performance, and operational metrics;

[0018] Requirements verification criteria: Establish acceptance criteria for each function to ensure that requirements can be quantified and verified.

[0019] Optionally, the aforementioned preliminary design includes: establishing a technical framework, bridging requirements and development, and specifically planning the system architecture from a macro perspective:

[0020] Non-functional analysis and design:

[0021] Application security analysis: Design a permission system and clarify data access control rules;

[0022] Performance indicator analysis: Develop performance optimization plans;

[0023] Operation and maintenance requirements analysis: Design log collection, monitoring and alarm schemes, and output operation and maintenance specification documents;

[0024] Based on the above analysis, a non-functional design scheme is proposed.

[0025] C'&D Model Design: Based on the ER diagram, conduct in-depth data model design:

[0026] Denormalization design: Add redundant fields to data tables with high-frequency join queries;

[0027] Primary key design: The snowflake algorithm is used to generate globally unique primary keys to ensure data uniqueness;

[0028] Redundant data design: Define the update rules for redundant fields and output the C'&D model design draft;

[0029] Application component / module design:

[0030] Divide components / modules according to business domains and define module boundaries;

[0031] Design module interfaces, clarify the calling relationships between modules, and output component / module division and interface documentation.

[0032] Structural design:

[0033] The package structure of the planning and development project;

[0034] Define the responsibilities and attributes of the core classes, and output the project structure and class design diagram.

[0035] Optionally, the process of transforming the framework into an executable solution, covering integration, implementation, and development, specifically includes: system integration design; logic unit design; program design; and modeling and functional analysis.

[0036] Optionally, the system integration design specifically includes:

[0037] Negotiate external system communication protocols;

[0038] Define the interface data format;

[0039] Write interface definition documents and output system integration solutions.

[0040] Optionally, the logic unit design specifically includes:

[0041] Access endpoint design: Define API interface endpoints and clarify request parameter validation rules;

[0042] Application layer design: Design the service layer logic;

[0043] Domain design: Divide the domain into objects and define the properties and methods of each object;

[0044] Infrastructure layer design: design the warehouse implementation, basic command components, and basic query components;

[0045] Service / Process Orchestration Design: The "Asset Disposal" process is orchestrated using a process engine, defining the service call logic corresponding to each node and outputting the logic unit design diagram.

[0046] Optionally, the program design specifically includes:

[0047] Report design: Clearly define the data source, display fields, and format;

[0048] Management Query Design: Design the query function of the back-end management terminal, clarify the query conditions and result display rules, and output reports and query design drafts.

[0049] Optionally, the modeling function analysis:

[0050] Based on the business modeling results, define the specific implementation logic of the application functions;

[0051] Write the processing flow;

[0052] Define the input / output explicitly;

[0053] Write business rules and output function implementation specifications.

[0054] This invention provides a software engineering implementation method, which includes: business modeling: anchoring the source of requirements and transforming business requirements into a feasible model; software requirements specification: solidifying requirement standards and forming a specification document based on the business modeling results; high-level design: building a technical framework, connecting requirements and development, and planning the system architecture from a macro perspective; and transforming the framework into an executable solution covering integration, implementation, and development. This software engineering implementation process is centered on a standardized "business modeling-driven" specification, constructing the core framework of the business architecture using a five-level process model and data model. It leverages structured views to connect the entire chain of "business requirements - data logic - IT design - implementation," deconstructing and breaking down complex processes / functions into microservice interface-level granularity, achieving precise correspondence and decoupling between business components and IT components, ultimately ensuring the efficient implementation of the business architecture within the IT architecture.

[0055] The above description is merely an overview of the technical solution of the present invention. In order to better understand the technical means of the present invention and to implement it in accordance with the contents of the specification, and in order to make the above and other objects, features and advantages of the present invention more apparent and understandable, specific embodiments of the present invention are described below. Attached Figure Description

[0056] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the 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.

[0057] Figure 1 This is a flowchart of a software engineering implementation method provided in an embodiment of the present invention. Detailed Implementation

[0058] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

[0059] The terms "comprising" and "having," and any variations thereof, in the specification, embodiments, claims, and drawings of this invention are intended to cover non-exclusive inclusion, such as including a series of steps or units.

[0060] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments.

[0061] This software engineering implementation process is based on a standardized "business modeling-driven" specification. It uses a five-level process model and data model to build the core framework of the business architecture. By using structured views, it connects the entire chain of "business requirements - data logic - IT design - implementation". Complex processes / functions are deconstructed and broken down into microservice interface-level granularity, achieving precise correspondence and decoupling between business components and IT components, and ultimately ensuring the efficient implementation of the business architecture in the IT architecture.

[0062] Example 1

[0063] The implementation plan for the process revolves around the core logic of "business modeling driving IT implementation". It focuses on five core aspects: business modeling, link connection, microservice decoupling, asset accumulation, and quality compliance. It clarifies specific technical strategies, methods, tools, and theoretical basis to ensure that the technical solution is implementable, reusable, and traceable.

[0064] like Figure 1 As shown, this process takes business modeling as its core. First, it clarifies the essence of the business through process modeling and data modeling. Then, it directly transforms the business logic into the basis for IT design through meta-model mapping (such as scenario workflow → system workflow, business entity → C / D model). Combined with structured views, it achieves deep integration of business and IT, solving the problem of deep disconnect between business and IT design.

[0065] This process includes the following steps:

[0066] I. Business Modeling: Anchoring the Source of Demand

[0067] Transforming business requirements into a feasible model involves the core tasks of:

[0068] Process modeling: Analyze the core business processes and clarify the nodes, logic, and related roles;

[0069] Data modeling: Define business data entities, attributes, and relationships;

[0070] User experience modeling: designing user interaction logic and interface prototypes;

[0071] Business function analysis: Decompose business objectives and clarify the core functions of modules.

[0072] II. Software Requirements Specification: Solidifying Requirements Standards

[0073] Standardized documents are generated based on the business modeling results, serving as the basis for subsequent design and ensuring accurate communication of requirements.

[0074] III. Overview Design: Building the Technical Framework

[0075] Connecting requirements and development, the system architecture is planned from a macro perspective, comprising five major modules:

[0076] Non-functional analysis: Focuses on non-business requirements to ensure system stability and availability, including application security, performance metrics, and operational requirements analysis;

[0077] C'&D Model Design: Deepen the data model, including denormalization, primary key, and redundant data design, and adapt to business storage calls;

[0078] Non-functional design: Develop implementation plans for non-functional requirements, including system security, data security, and system error handling design;

[0079] Application component / module design: Define module boundaries, clarify module definitions, interface design, and calling relationships; Project structure design: Plan the development project structure, including package structure and class design, to provide coding standards.

[0080] IV. Detailed Design: Technical Details for Implementation

[0081] Transform the framework into an executable solution, covering integration, implementation, and development:

[0082] System integration design: Define the rules for interaction with external systems, including communication protocols, interface data formats, and interface definitions;

[0083] Logical unit design: Refine the internal logic, including access endpoints, application layer, domain design (entity / aggregate / value objects, etc.), infrastructure layer (repository / command components, etc.), and service / process orchestration design;

[0084] Programming: Focus on functional development, including report design and management query design;

[0085] Modeling Function Analysis: Combine business modeling to refine the implementation logic, including application function definition, processing flow, input / output, and business rule writing.

[0086] The method of this invention is implemented in four progressive stages: "business modeling → requirement solidification → preliminary design → detailed design". Each stage includes clear technical operation steps and outputs, as detailed below:

[0087] Step 1: Business Modeling – Building a Basic Requirements Model

[0088] Guided by business objectives, the modeling process is completed through the following sub-steps, resulting in a business modeling deliverable set (including process model, data model, user experience prototype, and feature list):

[0089] 1.1 Process Modeling: Analyze the core business scenarios, use flowchart tools (such as BPMN) to define process nodes, flow logic and related roles, and clarify the input / output conditions of each node;

[0090] 1.2 Data Modeling: Based on business processes, identify core data entities (such as "asset information" and "approval records"), define entity attributes, data types, and relationships between entities (such as one-to-one and one-to-many), and output an ER diagram; 1.3 User Experience Modeling: Combine target user roles to design interface prototypes (including page layout, interaction logic, and operation paths) to ensure that the prototype matches the business processes; 1.4 Business Function Analysis: Decompose business objectives and transform process nodes into specific business functions (such as "asset disposal process" corresponding to "disposal application" and "approval workflow"), forming a function list and a mapping table between functions and processes.

[0091] Step 2: Software Requirements Specification Development – ​​Solidifying Requirements Standards

[0092] Based on the business modeling results set output from step 1, compile a software requirements specification document in a standardized format, specifying the following:

[0093] 2.1 Business Requirements: Refer to the function list in step 1.4 to explain the business value and application scenarios of each function; 2.2 Non-functional Requirements: Define system security (e.g., access control level), performance (e.g., response time ≤ 2s), and operation and maintenance (e.g., log storage period) indicators;

[0094] 2.3 Requirements Verification Standards: Establish acceptance criteria for each function (e.g., "Generate an approval number within 10 seconds after submitting the application") to ensure that requirements can be quantified and verified.

[0095] Step 3: High-level design – Building the technical architecture framework

[0096] Based on the software requirements specification, conduct macro-level technical planning and output a preliminary design document (including non-functional solutions, data models, component partitioning, and engineering structure). Specific sub-steps include:

[0097] 3.1 Non-functional analysis and design:

[0098] Application security analysis: Design a permission system (such as a role-permission mapping table) and clarify data access control rules; Performance indicator analysis: Develop performance optimization plans (such as caching strategies for high-frequency query interfaces);

[0099] Operation and maintenance requirements analysis: Design log collection, monitoring and alarm schemes, and output operation and maintenance specification documents;

[0100] Based on the above analysis, a non-functional design scheme (including security, performance, and operation and maintenance implementation measures) is output.

[0101] 3.2 C&D Model Design: Based on the ER diagram in step 1.2, conduct in-depth design of the data model:

[0102] Denormalization design: Add redundant fields to data tables with high frequency of join queries (e.g., add a "Customer Name" field to the "Orders" table to avoid join queries with the "Customers" table);

[0103] Primary key design: The snowflake algorithm is used to generate globally unique primary keys to ensure data uniqueness;

[0104] Redundant data design: Define the update rules for redundant fields (e.g., when the "Customer Name" changes, the corresponding field in the "Order Table" will be updated synchronously), and output the C'&D model design draft.

[0105] 3.3 Application Component / Module Design:

[0106] Divide components / modules by business domain (e.g., "Asset Management Component" and "Approval Component"), define module boundaries, design module interfaces (including interface name, input parameters, output parameters, and calling methods), clarify the calling relationships between modules (e.g., the "Approval Component" provides an interface for the "Asset Management Component" to call), and output component / module division and interface documentation.

[0107] 3.4 Engineering Structural Design:

[0108] The package structure of the planning and development project (e.g., “com.huaxia.asset.service” corresponds to the asset service layer);

[0109] Define the responsibilities and properties of core classes (such as "AssetController" and "ApprovalService"), and output the project structure and class design diagram.

[0110] Step 4: Detailed Design – Technical Implementation Details

[0111] Based on the preliminary design document from step 3, refine the technical implementation plan and output a detailed design document (including integration plan, logic implementation, program design, and functional analysis). Specific sub-steps include:

[0112] 4.1 System Integration Design:

[0113] Negotiate external system communication protocols (such as using RESTful API or WebSocket);

[0114] Define the interface data format (e.g., JSON format, specifying field types and required fields);

[0115] Write the interface definition document (including interface URL, request method, and exception code) and output the system integration solution.

[0116] 4.2 Logic Unit Design:

[0117] Access endpoint design: Define API interface endpoints (such as " / asset / dispose / apply" corresponding to asset disposal applications) and clarify the request parameter validation rules;

[0118] Application layer design: Design service layer logic (such as "DisposeService" to handle application submission and status update logic);

[0119] Domain design: Divide the domain objects (entities: Asset; aggregates: AssetAggregate; value objects: DisposeTime; domain services: AssetDisposeService; anti-corruption interface: ExternalApprovalAdapter), and define the properties and methods of each object;

[0120] Infrastructure layer design: Design the repository implementation (such as "AssetRepository" to connect to the database), basic command components (such as "CommandBus" to handle command distribution), and basic query components (such as "QueryExecutor" to execute SQL queries);

[0121] Service / process orchestration design: Use a process engine (such as Flowable) to orchestrate the "asset disposal" process, define the service call logic corresponding to the nodes, and output the logic unit design diagram.

[0122] 4.3 Programming:

[0123] Report design: Clearly define the data sources for the reports (e.g., the "Asset Disposal Statistics Report" takes data from the "Disposal Table" and "Approval Table"), and specify the display fields and formats (e.g., a bar chart displays the monthly disposal volume);

[0124] Management query design: Design the query function of the back-end management terminal (such as multi-condition filtering of "unapproved processing orders"), clarify the query conditions and result display rules, and output reports and query design drafts.

[0125] 4.4 Modeling Function Analysis:

[0126] Based on the business modeling results of step 1, define the specific implementation logic of the application functions (such as the "disposal application" function needing to verify asset status and generate approval forms);

[0127] Write the processing flow (e.g., "user submits application → system verification → generates approval form → pushes approval component"); clearly define the input / output (input: asset ID, disposal amount; output: approval form number, processing result);

[0128] Write business rules (e.g., "Disposal amount > 1 million requires general manager approval") and output the function implementation specification.

[0129] Example 2

[0130] The advantages of this process approach (a business model-driven software engineering design and implementation method) can be summarized into five core dimensions, all of which revolve around solving the pain points of traditional design and improving the efficiency and quality of the entire process, as follows:

[0131] I. End-to-end structured connection to ensure accurate implementation of requirements.

[0132] Key features: Following a progressive chain of "business modeling → requirement solidification → high-level design → detailed design," each stage clearly defines its inputs and outputs (e.g., business modeling outputs processes / data models, detailed design outputs integration solutions / logic unit design diagrams). Furthermore, each stage achieves seamless integration through mapping relationships (e.g., business functions correspond to IT interfaces, data models are associated with C&D models). Value derived: Completely solves the problem of "business and IT disconnect, isolated processes" in traditional linear transformation models. It can quickly locate requirement deviations, reduce the deviation rate in requirement implementation, and minimize ineffective development caused by distorted requirement transmission.

[0133] II. Deep collaboration between business and technology reduces rework costs.

[0134] Key performance indicators: The entire design process integrates "business logic analysis" with "technical solution design"—for example, clarifying data entities and functional boundaries during the business modeling phase, simultaneously conducting adaptation analysis of non-functional requirements (security, performance) and business requirements during the preliminary design phase, and decomposing functions at the microservice interface level during the detailed design phase (e.g., splitting "asset disposal" into independent application / approval interfaces) and verifying technical feasibility. Value derived: Avoiding the drawbacks of the traditional approach of "business first, technology later, resulting in a disconnect between the two," eliminating the risk of "business-feasible but technically unfeasible" from the design source, and significantly reducing rework rates later on.

[0135] Third, the architecture assets can be stored and reused, improving the efficiency of responding to changes in requirements.

[0136] Key performance indicators: All outputs at each stage (business modeling result set, C&D models, component interface documents, engineering structure design drawings) are stored as reusable architectural assets, and an inter-asset mapping is established (e.g., a change in a data field corresponds to adjustments in three microservice interfaces). Value derived: It abandons the traditional "delivery is the end" model. When requirements change, there's no need to redesign from scratch. Based on asset mapping relationships, impact assessments can be completed within 1-2 business days, significantly improving requirement response efficiency and reducing the development costs of "reinventing the wheel."

[0137] IV. The entire process is standardized and reproducible, ensuring the stability of design quality.

[0138] Key features: Each stage defines standardized operating procedures (e.g., using BPMN tools for process modeling and the Snowflake algorithm for primary key design) and output specifications (e.g., including standardized acceptance criteria in the requirements specification document and component division rules in the preliminary design document), without relying on personal experience. Value derived: It solves the problem of traditional design being "variable from person to person, resulting in large quality fluctuations." This method can be quickly reused in different enterprise-level projects (e.g., financial asset systems, government approval systems), ensuring consistency and stability of design quality.

[0139] V. Refined design covers all scenarios and adapts to enterprise-level system requirements.

[0140] Key Performance: The design granularity balances both "macro-architecture" and "micro-details"—at the macro level, a high-level design builds the component / engineering structure framework; at the micro level, detailed design covers all scenarios, including domain objects (entities / aggregates / value objects), system integration (protocols / interface formats), and program implementation (reports / management queries). Separate implementation solutions are also designed for non-functional requirements (security, operations and maintenance). Value Brought: It can adapt to the design requirements of complex enterprise-level systems, satisfying both architectural flexibility (such as microservice decoupling to support module expansion) and ensuring the feasibility of detailed implementation (such as data security design meeting industry compliance requirements). The resulting system possesses the dual advantages of "clear business logic" and "robust technical architecture."

[0141] Beneficial effects:

[0142] 1. End-to-end structured view connectivity mechanism

[0143] Breaking through the limitations of traditional processes' "linear transformation in a single link," we construct a full-link structured view covering "business model (process / data / page prototype) - requirement specification - IT design (high-level design)." Through cross-link correlation mapping, we can quickly locate the gap between business and IT, thereby improving the accuracy of requirement implementation and the traceability of the entire chain from the root.

[0144] 2. Microservice-level refined decoupling and process integration model

[0145] Innovatively, the functional decomposition granularity is refined to the microservice interface level (such as splitting business processes into independent interface units), achieving ultimate decoupling; at the same time, it integrates the "business logic decomposition (application analysis)" and "technology solution selection (preliminary design)" processes that are separated in traditional processes, verifying technical feasibility in the design phase, avoiding rework caused by the disconnect between business and technology, and improving design efficiency.

[0146] 3. Architectural Asset Accumulation and Dynamic Impact Assessment System

[0147] Abandoning the traditional "delivery is the end" model, we proactively accumulate reusable architectural assets such as process models, data models, and microservice interface specifications, and establish asset association mapping relationships. When business requirements change, we can quickly complete the impact assessment based on the mapping relationship (1-2 working days), realizing the transformation from "passive response" to "proactive prediction", and significantly improving the efficiency of demand response and the value of asset reuse.

[0148] The above specific embodiments further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above are merely specific embodiments of the present invention and are not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A software engineering implementation method, characterized by, The engineering implementation method comprises: Business modeling: anchor the demand source, and convert business demand into a landable model; Software requirement specification: solidify the demand standard, and form a specification document based on the business modeling results; High-level design: build a technical framework, and link the demand and development to plan the system architecture from a macro perspective; Convert the framework into an executable solution, covering integration, implementation, and development.

2. The method of claim 1, wherein, The business modeling: anchoring the demand source, and converting business demand into a landable model specifically comprises: Process modeling: comb the business core scene, use process diagram tools to define process nodes, flow logic, and associated roles, and clearly define the input / output conditions of each node; Data modeling: based on the business process, identify core data entities, define entity attributes, data types, and entity relationship, and output an ER diagram; User experience modeling: combine target user roles, design interface prototypes, and ensure that the prototypes match the business process; Business function analysis: disassemble business goals, convert process nodes into specific business functions, and form a function list and a function-to-process mapping table.

3. The method of claim 1, wherein, The software requirement specification: solidify the demand standard, and form a specification document based on the business modeling results specifically comprises: Business demand: reference the function list to explain the business value and application scenarios of each function; Non-functional requirements: define system security, performance, and operation and maintenance indicators; Demand verification standard: develop acceptance conditions for each function to ensure that the demand can be quantitatively verified.

4. The method of claim 1, wherein, The high-level design: build a technical framework, and link the demand and development to plan the system architecture from a macro perspective specifically comprises: Non-functional analysis and design: Application security analysis: design a permission system and clearly define data access control rules; Performance indicator analysis: develop a performance optimization plan; Operation and maintenance requirement analysis: design a log collection, monitoring, and alarm solution, and output an operation and maintenance specification document; Based on the above analysis, output the non-functional design solution; C'&D model design: based on the ER diagram, carry out data model deepening design: Anti-paradigm design: add redundant fields to the data table with high-frequency association query; Primary key design: use the snowflake algorithm to generate a globally unique primary key to ensure data uniqueness; Redundant data design: define the update rules of redundant fields, and output the C'&D model design; Application component / module design: Divide components / modules according to business domains, and define module boundaries; Design module interfaces, clearly define module calling relationships, and output component / module division and interface documents. Engineering structure design: Plan the package structure of the development project; Define the responsibilities and attributes of core classes, and output the engineering structure and class design diagram.

5. The software engineering implementation method of claim 1, wherein, The conversion of the framework into an executable solution, covering integration, implementation, and development specifically comprises: system integration design; logic unit design; program design; and modeling function analysis.

6. The software engineering implementation method of claim 5, wherein, The system integration design specifically comprises: Negotiate external system communication protocols; Define interface data formats; Write interface definition documents, and output system integration solutions.

7. The method of claim 5, wherein, The logic unit design specifically comprises: Access endpoint design: define API interface endpoints, and clearly define request parameter verification rules; Application layer design: design service layer logic; Domain design: divide domain objects, and define the attributes and methods of each object; Infrastructure layer design: design warehouse implementation, basic command components, basic query components; Service / flow arrangement design: use the process engine to arrange the "asset disposal" process, define the service call logic corresponding to the nodes, and output the logical unit design diagram.

8. The software engineering implementation method of claim 5, wherein, The program design specifically includes: Report design: clearly define the report data source, display field and format; Management query design: design the query function of the background management end, clearly define the query conditions and result display rules, and output the report and query design draft.

9. The software engineering implementation method of claim 5, wherein, The modeling function analysis: Based on the business modeling results, define the specific implementation logic of the application function; Write processing flow; Define input / output definition; Write business rules and output function implementation specification.

Images