Project change processing method and system

Abstract

This application discloses a project change processing method and system, relating to the field of computer technology. The method includes: obtaining production version and development version comparison information for each resource under the target project; performing database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the production version and development version comparison information to obtain change analysis results; performing association mapping on each change list in the change analysis results based on a preset change impact association engine to obtain association mapping results; deduplicating and merging duplicates in the association mapping results to determine the panoramic data of project changes. This can solve the problem that existing code analysis tools only analyze code quality and lack a business impact perspective, making it difficult to analyze comprehensively. By uniformly associating code changes, database changes, configuration changes, and SDK changes through project numbers, a panoramic change impact analysis can be performed from the perspective of the project.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to methods and systems for handling project changes. Background Technology

[0002] Traditional project impact analysis relies on developers' familiarity with the project, which has the following obvious drawbacks: (1) Single analysis dimension: Existing code analysis tools (such as SonarQube, FindBugs, etc.) only analyze code quality and lack a business impact perspective. Moreover, due to the large number of factors affecting API changes, existing analysis tools are difficult to analyze comprehensively.

[0003] (2) Changes do not penetrate the SDK: Existing application change analysis solutions only analyze changes at the application level and cannot analyze changes to the SDKs referenced by the application, resulting in an incomplete understanding of the scope of impact.

[0004] (3) Lack of summarization and integration: The existing project management plan is not related to the scope of project changes and lacks integration of project dimensions. Especially for large projects, there are many and scattered changes. When multiple developers are working on the project, some changes will overlap and affect each other. Developers are prone to not being able to sort them out completely, resulting in insufficient testing and affecting project quality. Summary of the Invention

[0005] The main purpose of this application is to provide a method and system for handling project changes, which aims to solve the problems that existing code analysis tools only analyze code quality and lack a business impact perspective. Furthermore, due to the large number of factors affecting API changes, existing analysis tools are unable to analyze comprehensive technical issues.

[0006] According to one aspect of the present invention, a project change processing method is provided, the project change processing method comprising: Obtain information comparing the production and development versions of each resource under the target project; Based on the comparison information between the production version and the development version, database change analysis, code change impact analysis, SDK change analysis, and platform configuration change analysis are performed to obtain change analysis results. Based on the preset change impact correlation engine, the change list in the change analysis results is correlated and mapped to obtain the correlation mapping results; Duplicate items in the association mapping results are deduplicated and merged to determine the panoramic data of project changes.

[0007] In one implementation, obtaining the comparison information between the production version and the development version of each resource under the target project includes: Retrieve the application version list and database version list associated with the project number from the configuration management system; Based on the application version list, obtain the code version tag for each associated application. The code version tag by default includes the production version tag and the latest version tag that is the same as the production version branch. Based on the database version list, obtain the version snapshot, modified data tables, and index version for each database; The configuration version of the application is obtained from the configuration management system based on the application version list; Based on the code version tag, the database version snapshot, and the configuration version, the comparison information between the production version and the development version is determined.

[0008] In one implementation, the step of performing database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the comparison information between the production version and the development version to obtain change analysis results includes: Based on the comparison information between the production version and the development version, a database change analysis was performed to obtain the database change analysis results. Based on the comparison information between the production version and the development version, an impact analysis of code changes was performed to obtain the results of the impact analysis of code changes. Based on the comparison information between the production version and the development version, SDK change analysis is performed to obtain SDK change analysis results; Based on the comparison information between the production version and the development version, a platform configuration change analysis was performed to obtain the platform configuration change analysis results. The change analysis results are determined based on the database change analysis results, the code change impact analysis results, the SDK change analysis results, and the platform configuration change analysis results.

[0009] In one implementation, the step of performing database change analysis based on the comparison information between the production version and the development version to obtain database change analysis results includes: The database structure of the current development version is compared with the version actually deployed in the production environment to obtain version comparison results; Based on the version comparison results, extract the database differences and custom SQL scripts to obtain a database change list; The database change analysis results are determined based on the database change list.

[0010] In one implementation, the step of performing code change impact analysis based on the comparison information between the production version and the development version to obtain the code change impact analysis results includes: The code hosting platform tags are compared based on the tags of the production version and the latest tags that are the same as the production version branch. The commit record list of the current project is determined based on the tag comparison results. The code parsing tool is determined based on the list of submission records; The code parsing tool is used to parse all API interface definitions in the application, determine the API call chain, and construct a directed API call graph based on the API call chain. In the directed graph of API calls, reverse the search to find the API-affected nodes and determine the list of APIs affected by the code changes; The impact analysis results of the code change are determined based on the list of APIs affected by the code change.

[0011] In one implementation, the step of performing SDK change analysis based on the comparison information between the production version and the development version to obtain SDK change analysis results includes: Based on the comparison information between the production version and the development version, SDK call chain analysis is performed to determine the SDK code call path; Determine whether there are any changes to the SDK call based on the SDK code call path; If there is an SDK call change and the SDK code call path is called in the API call chain, then the API is determined to be affected by the SDK change, and a list of APIs affected by the SDK change is determined. If there is an SDK call change and the SDK code call path is not called in the API call chain, then the API is determined to be unaffected by the SDK change. The SDK change analysis results are determined based on the list of APIs affected by the SDK changes.

[0012] In one implementation, the step of performing association mapping on each change list in the change analysis result based on a preset change impact association engine to obtain association mapping results includes: Associate the database difference items in the database change list with the corresponding database versions to obtain the database change association results; Associate the APIs in the API list affected by the code changes with the corresponding code changes to obtain the code change association results; Associate the APIs in the list of APIs affected by the SDK changes with the corresponding SDK changes to obtain the SDK change association results; Associate the configuration change items in the configuration change impact analysis report with the corresponding application version to obtain the platform configuration change association results; Based on the database change association results, the code change association results, the SDK change association results, and the platform configuration change association results, an association mapping result is generated. The association mapping result contains a many-to-many mapping relationship between each change source and the affected resources.

[0013] In one implementation, the step of deduplicating and merging duplicate items in the association mapping result to determine the project change panorama data includes: If the same API is affected by multiple changes, the affected records will be merged after deduplication to determine the overall change data of the project. The project change overview data includes a summary of changes by change type and a list of affected APIs.

[0014] In one implementation, after deduplicating and merging duplicate items in the association mapping result to determine the changed panoramic data for the project, the method further includes: The project's panoramic data is visualized to generate a panoramic display.

[0015] This invention addresses the problem that existing code analysis tools only analyze code quality and lack a business impact perspective. Furthermore, due to the large number of factors affecting API changes, existing analysis tools struggle to provide a comprehensive analysis. By using project numbers to uniformly link code changes, database changes, configuration changes, and SDK changes, a panoramic change impact analysis is conducted from a project perspective.

[0016] According to another aspect of the present invention, a project change processing system is provided, comprising: The version acquisition module is used to obtain information comparing the production and development versions of each resource under the target project. The change analysis module is used to perform database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the comparison information between the production version and the development version, and to obtain change analysis results. The change association module is used to perform association mapping on each change list in the change analysis results based on a preset change impact association engine, and obtain the association mapping results; The change association module is also used to remove duplicates and merge duplicates in the association mapping results to determine the panoramic data of project changes. Attached Figure Description

[0017] 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.

[0018] 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.

[0019] Figure 1 This is a flowchart illustrating one embodiment of the method for handling changes to the project in this application. Figure 2 This is a schematic diagram of the overall architecture of a project overview for one embodiment of the project change processing method of this application; Figure 3 This is a flowchart illustrating another embodiment of the method for handling changes to the project in this application. Figure 4 This is a flowchart illustrating the impact analysis of code changes in another embodiment of the change handling method for this application. Figure 5 This is a flowchart illustrating yet another embodiment of the method for handling changes to the project in this application. Figure 6 This is a schematic diagram of the structure of the project change processing system according to an embodiment of this application; Figure 7 This is a schematic diagram of the hardware operating environment involved in the project change processing method in this application embodiment.

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

[0021] 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.

[0022] 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.

[0023] The main solution of this application embodiment is: to obtain the comparison information between the production version and the development version of each resource under the target project; to perform database change analysis, code change impact analysis, SDK change parsing and platform configuration change analysis based on the comparison information between the production version and the development version, and obtain change analysis results; to perform association mapping on each change list in the change analysis results based on the preset change impact association engine, and obtain association mapping results; to remove duplicates and merge duplicates in the association mapping results, and determine the panoramic data of project changes.

[0024] Existing code analysis tools only analyze code quality and lack a business impact perspective. Furthermore, due to the numerous factors affecting API changes, existing analysis tools struggle to provide a comprehensive analysis.

[0025] This application provides a solution that obtains the comparison information between the production and development versions of each resource under the target project, and performs database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the comparison information to obtain change analysis results. It then uses a preset change impact correlation engine to correlate and map each change list in the change analysis results to obtain correlation mapping results. Finally, it removes and merges duplicates in the correlation mapping results to determine the overall change data for the project. This solution addresses the problems of existing code analysis tools that only analyze code quality and lack a business impact perspective, and the difficulty of comprehensive analysis due to the numerous factors affecting API changes. By using project numbers to uniformly correlate code changes, database changes, configuration changes, and SDK changes, it provides a panoramic change impact analysis from a project perspective.

[0026] 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 project change processing device capable of performing the above functions. This embodiment does not specifically limit it. The following uses a project change processing device as an example to describe this embodiment and the following embodiments.

[0027] This application provides a method for handling project changes, referring to... Figure 1 , Figure 1 This is a flowchart illustrating a feasible embodiment of the method for handling changes to the project in this application.

[0028] In this embodiment, the project change processing method includes steps S10 to S40: Step S10: Obtain the comparison information between the production version and the development version of each resource under the target project.

[0029] Among them, reference Figure 2The diagram shown illustrates the overall architecture of the project panorama. The project panorama performs change analysis on all applications and databases involved in a given project, organized by project number. It is divided into a data acquisition layer, a data analysis layer, and a data visualization layer. The relationships between these layers are explained below: The data acquisition layer is the input source for the entire solution: it obtains information such as the project's code version tag, database version, and configuration version through the project number, serving as the foundational data for subsequent analysis. The data analysis layer is the core processing engine of the entire solution: after the acquisition layer obtains the version information, the four analyzers in the analysis layer (database change analyzer, application code change analyzer, configuration change analyzer, and SDK code change analyzer) work in parallel to extract various types of change content. The key connecting point is that all change data output by the analyzers is aggregated into the "Change Impact Correlation Engine," which is the core component connecting all change analysis results. The data visualization layer is the final output: it visualizes the "change data and impact scope" output by the correlation engine to generate the project change panorama.

[0030] In one implementation, the core process of the data analysis layer is: version collection, change extraction, link analysis, impact correlation, and summary output. The detailed steps are as follows: obtain the production version and development version comparison information of each resource under the target project from the configuration management system according to the project number.

[0031] In one implementation, through version collection and difference analysis, step S10 further includes: obtaining a list of application versions and a list of database versions associated with the project number from the configuration management system based on the project number; obtaining a code version tag for each associated application based on the application version list, wherein the code version tag defaults to obtaining a production version tag and a latest version tag that is the same as the production version branch; obtaining a version snapshot, modified data tables, and index version for each database based on the database version list; obtaining the configuration version of the application from the configuration management system based on the application version list; and determining the comparison information between the production version and the development version based on the code version tag, the database version snapshot, and the configuration version.

[0032] Input: Project number; Processing logic: (1) Obtain the list of associated application versions and database versions of the project from the configuration management system based on the project number. (2) Obtain the code version tag of each associated application (the production version tag and the latest version tag are taken by default). (3) Obtain the version snapshot of each database and the modified data table / index version. (4) Obtain the configuration version of the application based on the application version list. Output: Version comparison information of each resource under the project (production version vs. development version).

[0033] In one implementation, after developers create a refactoring project and associate it with the order-related application in the project management system, the system automatically retrieves the production version tag (e.g., v1.2.3) of the order application and the latest version tag (e.g., v1.2.4) of the current development branch from the Git code hosting platform, obtains the production version snapshot and the current development version snapshot of the order database from the database version management tool, and obtains the production environment configuration version and development environment configuration version of the order application from the configuration center. The system organizes the above information into a version comparison information table, which serves as a unified input for subsequent analysis.

[0034] Step S20: Based on the comparison information between the production version and the development version, perform database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis to obtain change analysis results.

[0035] The obtained version comparison information is analyzed in parallel by four analyzers: database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis. The code change impact analysis includes: locating the method to which the changed code belongs based on the number of lines of code; reverse-engineering the API nodes affected by the method in a pre-built directed API call graph; and identifying the found API nodes as the APIs affected by the code change.

[0036] In one implementation, database change analysis is performed based on the comparison information between production and development versions to obtain database change analysis results; code change impact analysis is performed based on the comparison information between production and development versions to obtain code change impact analysis results; SDK change analysis is performed based on the comparison information between production and development versions to obtain SDK change analysis results; platform configuration change analysis is performed based on the comparison information between production and development versions to obtain platform configuration change analysis results; and the change analysis results are determined based on the database change analysis results, code change impact analysis results, SDK change analysis results, and platform configuration change analysis results.

[0037] Step S30: Based on the preset change impact association engine, perform association mapping on each change list in the change analysis result to obtain the association mapping result.

[0038] Specifically, based on a preset change impact correlation engine, the database change analysis results, code change impact analysis results, SDK change analysis results, and platform configuration change analysis results in the change analysis results are correlated and mapped to obtain correlation mapping results.

[0039] The association mapping results include database change association results, code change impact association results, SDK change association results, and platform configuration change association results.

[0040] Step S40: Duplicate items in the association mapping results are deduplicated and merged to determine the panoramic data of the project change.

[0041] Specifically, duplicate items in the association mapping results—database change association results, code change impact association results, SDK change association results, and platform configuration change association results—are deduplicated and merged to determine the overall picture of project changes.

[0042] In one implementation, step S40 further includes: if the same API is affected by multiple changes, the affected records are deduplicated and merged to determine the overall change data of the project.

[0043] The project change overview data includes a summary of changes by change type and a list of affected APIs.

[0044] In one implementation, when the same API is affected by multiple changes, including code changes, SDK changes, and configuration changes, the impact records of the API are deduplicated and merged into a single record; the project change panorama data includes change summary information statistically analyzed by change type, a list of affected APIs, and all change content associated with each API and its change source.

[0045] In one implementation, after step S40, the method further includes: visualizing the panoramic data of the project change to generate a panoramic display.

[0046] The project's change panoramic data is visualized to generate a panoramic display.

[0047] The panoramic display includes at least one of the following: Change Summary View: Displays the number of changes according to the categories of database changes, application changes, and SDK changes; Affected API List: Displays all affected APIs, supporting filtering by impact level; Change Tracking Information: In response to user clicks on a target API, displays all changes associated with that API and their sources; Release List: Generates a release list containing the change code commit ID, SQL script, YML configuration, business startup configuration, and API authentication configuration that need to be released.

[0048] For example, the data presentation layer visualizes the output of the panoramic data of project changes: (1) Change summary view: display change statistics by type (database, application, SDK); (2) Affected API list: display all affected APIs, and support filtering by degree of impact; (3) Change traceability: click on an API to see the specific changes that caused the API to be affected; (4) Release list: generate a complete release list, including the change code commits, SQL scripts, YML configurations, business startup configurations, API authentication configurations, etc. that need to be released.

[0049] This embodiment obtains the comparison information between the production version and the development version of each resource under the target project; based on the comparison information, it performs database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis to obtain change analysis results; based on a preset change impact association engine, it performs association mapping on each change list in the change analysis results to obtain association mapping results; it removes duplicates from the association mapping results and merges them to determine the panoramic data of project changes. This can solve the problem that existing code analysis tools only analyze code quality and lack a business impact perspective, and that existing analysis tools cannot analyze comprehensively due to the large number of factors affecting API changes. By using project numbers to uniformly associate code changes, database changes, configuration changes, and SDK changes, a panoramic change impact analysis can be performed from the perspective of the project.

[0050] In one feasible 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. Based on this, please refer to... Figure 3 Step S20 further includes: Step S201: Perform database change analysis based on the comparison information between the production version and the development version to obtain the database change analysis results.

[0051] Specifically, database change analysis is performed on data tables, indexes, and custom SQL scripts based on the comparison information between production and development versions to obtain database change analysis results.

[0052] In one implementation, step S201 further includes: comparing the database structure of the current development version with the version actually deployed in the production environment to obtain a version comparison result; extracting database difference items and custom SQL scripts based on the version comparison result to obtain a database change list; and determining the database change analysis result based on the database change list.

[0053] Among them, database change analysis, the analysis objects are: data tables, indexes, and custom SQL scripts, and the processing logic is: (1) After the user modifies the data table or index, the system will generate a new version snapshot; (2) Compare the database structure of the current development version with the version actually deployed in the production environment; (3) Extract the differences: adding tables / fields, modifying field types, deleting fields, adding / deleting indexes, etc.; (4) At the same time, extract the custom SQL scripts written during the project development process (such as data migration scripts, initialization scripts, etc.); Output: database change list (DDL changes, custom script list).

[0054] For example, the current development version of the order database structure is compared with the actual database structure deployed in the production environment, and the differences are extracted, including identifying newly added data tables, modified field types, and newly added indexes, while also extracting the custom SQL migration scripts written in the project.

[0055] Step S202: Based on the comparison information between the production version and the development version, perform code change impact analysis to obtain the code change impact analysis results.

[0056] Among them, reference Figure 4 The flowchart shown illustrates the code change impact analysis process, which includes three sub-steps that are interconnected: baseline selection - code submission comparison, API call chain analysis, and API impact analysis.

[0057] In one implementation, step S202 further includes: comparing the tags of the production version with the latest tags that are the same as the production version branch on the code hosting platform, and determining the commit record list of the current project based on the tag comparison results; determining the code parsing tool based on the commit record list; parsing all API interface definitions in the application based on the code parsing tool, determining the API call chain, and constructing an API call directed graph based on the API call chain; reverse-searching the API impact nodes in the API call directed graph to determine the list of APIs affected by code changes; and determining the code change impact analysis results based on the list of APIs affected by code changes.

[0058] In one implementation, the baseline selection-code commit comparison is as follows: (1) By default, the label of the production version is compared with the latest label of the same branch as the production version; (2) By selecting two labels for comparison, the commit list of the current project is obtained; (3) At the same time, users can customize the selection of branches, labels or commit IDs for comparison. API call chain parsing: (1) After obtaining the commits submitted under the project in the previous step, the code line number corresponding to the changed code will be obtained; (2) The code of the application's Gitee project is pulled, and then the API call chain is parsed based on the JavaParser tool; (3) Specific parsing process: Parse all Controller layer API interface definitions in the application, starting from each API interface method, and parse the call chain layer by layer (method call, other methods called inside the method, SQL operation, etc.), build a complete API call directed graph, traverse the code line where the changed code is located, locate the method to which the code line belongs, and find the API node affected by the method in the API call directed graph. API impact analysis of changes: (1) If the method body containing the code change line number is in the API call chain, it is identified that the current project of the API has been changed; (2) Output a list of all APIs affected by the code change; Output: List of APIs affected by code change.

[0059] For example, firstly, the system retrieves a list of commit records (a total of 23 commits) between the production version (v1.2.3) and the development version (v1.2.4) from the code hosting platform. Then, it pulls the complete codebase of the order application, starts the JavaParser parsing engine, and scans all Controller-level API interfaces in the application. Starting from each API method (e.g., / api / order / create), it parses the call chain layer by layer downwards (Controller, Service, DAO, SQL operations), constructing a complete directed API call graph. Next, the system traverses the changed lines of code in the 23 commits (involving 156 files and 342 lines of code changes), locates the method to which each changed line belongs (e.g., OrderService.calculateOrderAmount()), and traces back upwards from this method in the directed API call graph to find all API nodes that call this method. If the call chain of an API contains the changed method, then that API is identified as an affected API.

[0060] Example application scenario: A financial service system's "Account Balance Inquiry" API ( / account / balance) calls an underlying account balance calculation service. Developers modified a precision calculation method, `calculateAmount()`, within this service. Through code change impact analysis: the system identified the call path of the `calculateAmount()` method to the "Account Balance Inquiry" API; automatically linked it to the affected API; and output an impact list: [API: / account / balance-Account Balance Inquiry]; thus, developers know that modifying this method affects the "Account Balance Inquiry" API and need to notify relevant testers to test the API.

[0061] Step S203: Based on the comparison information between the production version and the development version, perform SDK change analysis to obtain SDK change analysis results.

[0062] In one implementation, step S203 further includes: performing SDK call chain analysis based on the comparison information between the production version and the development version to determine the SDK code call path; determining whether there is an SDK call change based on the SDK code call path; if there is an SDK call change and the SDK code call path is called in the API call chain, then the API is determined to be affected by the SDK change, and a list of APIs affected by the SDK change is determined; if there is an SDK call change and the SDK code call path is not called in the API call chain, then the API is determined to be unaffected by the SDK change; and determining the SDK change analysis result based on the list of APIs affected by the SDK change.

[0063] Among them, the SDK change analysis and processing logic are as follows: (1) After the application code change scan is completed, the code scan of the application referencing the SDK is further added; (2) The scanning logic is roughly the same as the application code analysis: perform call chain analysis on all public methods of the SDK; parse the path of the SDK method being called by the application code; find out if there are any changes to the SDK method in the application call chain; (3) If the SDK method is changed and the method is called in the API call chain of the application, then the API is affected; Output: list of APIs affected by SDK change.

[0064] For example, scanning the order application's dependency configuration files (such as pom.xml) revealed that the project had introduced the Inventory Locking SDK, upgraded from version v1.0.0 to v1.1.0. The system then analyzed the call chain of all public methods in the Inventory Locking SDK, parsing the paths where these methods were called by the order application code. It was found that the StockService.lockStock() method of the Inventory Locking SDK was called in the call chain of the order creation API. This method had a signature change in the new version of the SDK, thus confirming that the "Create Order" API was affected by this SDK change.

[0065] Example application scenario: The project introduced a third-party payment SDK version 2.1.0. After the SDK was upgraded to version 2.2.0, the signature of the PayService.pay() method changed (a new encrypted parameter was added). SDK change analysis: The system detected a change in the SDK's PayService.pay() method; analysis of the application's call chain revealed that the "Payment Order" API called the PayService.pay() method; this API was automatically associated with the change; output: SDK change impact [API: / payment / create-Payment Order].

[0066] Step S204: Based on the comparison information between the production version and the development version, perform platform configuration change analysis to obtain the platform configuration change analysis results.

[0067] Specifically, the modified configuration of the current version is compared with the actual configuration deployed in the production environment, and a differential analysis is performed according to different configuration types. The configuration types include at least one of the following: YML configuration file, business startup configuration, and API authentication configuration. For YML configuration files, the configuration item changes are parsed and compared with the production version YML configuration. For business startup configuration, the business startup configuration modules affected by the changes are identified. For API authentication configuration, the list of APIs affected by the changes in authentication rules is identified.

[0068] In one implementation, the platform configuration change analysis includes configuration types such as YML configuration files, business startup configurations, and API authentication configurations. The processing logic is as follows: (1) When a change occurs, the version is associated with the project; (2) The configuration after the current version is modified is compared with the configuration actually deployed in the production environment; (3) Different comparative analyses are performed according to different configuration types: YML configuration: Parse the configuration item changes and compare them with the production version YML configuration; Business startup configuration: Identify the business startup configuration module affected by the change; API authentication configuration: Identify the list of APIs affected by the change in authentication rules; Output: Configuration change impact analysis report.

[0069] For example, by comparing the order application configuration in the current development environment with the configuration in the production environment, it was found that the API authentication configuration has added an authentication rule for the / api / order / refund interface, and the database connection pool size in the YML configuration file has been adjusted from 10 to 20.

[0070] Example application scenario: The project modified the API authentication configuration: a new " / api / order / refund" interface was added that requires authentication verification; the authentication level of the " / api / user / profile" interface was changed from warning level to blocking level; through configuration change analysis: compared with the production version configuration, the system identified the authentication configuration change in the current development version; associated with the specific API; output: new authentication API: [ / api / order / refund]; permission change API: [ / api / user / profile].

[0071] Step S205: Determine the change analysis results based on the database change analysis results, the code change impact analysis results, the SDK change analysis results, and the platform configuration change analysis results.

[0072] The change analysis results are determined based on the database change analysis results, code change impact analysis results, SDK change analysis results, and platform configuration change analysis results.

[0073] This embodiment obtains the comparison information between the production version and the development version of each resource under the target project; based on the comparison information, it performs database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis to obtain change analysis results; based on a preset change impact association engine, it performs association mapping on each change list in the change analysis results to obtain association mapping results; it removes duplicates from the association mapping results and merges them to determine the panoramic data of project changes. This can solve the problem that existing code analysis tools only analyze code quality and lack a business impact perspective, and that existing analysis tools cannot analyze comprehensively due to the large number of factors affecting API changes. By using project numbers to uniformly associate code changes, database changes, configuration changes, and SDK changes, a panoramic change impact analysis can be performed from the perspective of the project.

[0074] In one feasible 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. Based on this, please refer to... Figure 5 Step S30 further includes: Step S301: Associate the database difference items in the database change list with the corresponding database version to obtain the database change association result; In one implementation, a change list output from four analyzers is received, and a unified association processing is performed through the change impact association engine to associate the database change (adding 3 fields to the order table) with the database version v1.2.4 to obtain the database change association result.

[0075] Step S302: Associate the APIs in the API list affected by the code change with the corresponding code changes to obtain the code change association results; In one implementation, the code change (modification of the calculateOrderAmount() method) is associated with the affected API ( / api / order / balance account balance query API) to obtain the code change association result.

[0076] Step S303: Associate the APIs in the list of APIs affected by the SDK change with the corresponding SDK changes to obtain the SDK change association results; In one implementation, the SDK change (inventory lock SDK upgrade) is associated with the affected API ( / api / order / create order creation API) to obtain the SDK change association result.

[0077] Step S304: Associate the configuration change items in the configuration change impact analysis report with the corresponding application version to obtain the platform configuration change association results; In one implementation, configuration changes (authentication rule modifications) are associated with the affected API ( / api / order / refund) to obtain platform configuration change association results.

[0078] Step S305: Generate association mapping results based on the database change association results, the code change association results, the SDK change association results, and the platform configuration change association results.

[0079] The association mapping result includes a many-to-many mapping relationship between each change source and the affected resources.

[0080] In one implementation, all change analysis results are integrated through a change impact correlation engine. The processing logic is as follows: (1) Receive the change list output by each analyzer; (2) Receive the impact mapping relationship output by the call link analysis engine; (3) Perform unified correlation processing: correlate data table / index changes with database version; correlate code changes with affected APIs; correlate SDK changes with affected APIs; correlate configuration changes with affected application versions, and generate correlation mapping results.

[0081] Example application scenario 1: Refactoring of the order module under a microservice architecture. Scenario description: An e-commerce platform refactors its order module, involving the following changes: Database: Order table structure optimized, new fields added; Code: The order service layer methods have been refactored, and the order status calculation logic has been modified; Configuration: Adjustments to authentication rules for order-related APIs; SDK: A new inventory locking SDK has been introduced; Implementation steps: (1) Developers create a refactoring project in the project management system and associate it with order-related applications; (2) The system automatically collects the production version tags and development version tags of the order application and database; (3) The system performs change analysis: Database change analysis: Identifies 3 new fields added to the order table; Code change analysis: Through call chain analysis, it identifies 5 APIs affected, such as "Create Order", "Query Order", and "Cancel Order"; Configuration change analysis: It identifies 2 APIs affected by the authentication rule change; SDK change analysis: It identifies the "Create Order" API affected by the inventory lock SDK change; (4) The system outputs a panoramic view of project changes: Total number of affected APIs: 7, Database changes that need to be released: 1 table, Configuration changes that need to be released: 2 items, SDK updates that need to be released: 1. Developers can know all the impact scope at once, avoiding the tedious process of communicating and confirming one by one in the traditional way.

[0082] This embodiment obtains the comparison information between the production version and the development version of each resource under the target project; based on the comparison information, it performs database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis to obtain change analysis results; based on a preset change impact association engine, it performs association mapping on each change list in the change analysis results to obtain association mapping results; it removes duplicates from the association mapping results and merges them to determine the panoramic data of project changes. This can solve the problem that existing code analysis tools only analyze code quality and lack a business impact perspective, and that existing analysis tools cannot analyze comprehensively due to the large number of factors affecting API changes. By using project numbers to uniformly associate code changes, database changes, configuration changes, and SDK changes, a panoramic change impact analysis can be performed from the perspective of the project.

[0083] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the method of changing the project of this application. Any simple changes based on this technical concept are within the protection scope of this application.

[0084] refer to Figure 6 This application also provides a project change processing system, including: Version acquisition module 10 is used to obtain information on the comparison between the production version and the development version of each resource under the target project; The change analysis module 20 is used to perform database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the comparison information between the production version and the development version, and to obtain change analysis results. The change association module 30 is used to perform association mapping on each change list in the change analysis result based on a preset change impact association engine to obtain the association mapping result; The change association module 30 is also used to remove duplicates and merge duplicates in the association mapping result to determine the panoramic data of project changes.

[0085] This application provides a project change processing 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, which are executed by the at least one processor to enable the at least one processor to perform the project change processing method in Embodiment 1 above.

[0086] The following is for reference. Figure 7 The diagram illustrates a structural schematic of a project change processing device suitable for implementing embodiments of this application. The project change processing device in 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 7 The project change processing 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.

[0087] like Figure 7As shown, the project change processing 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 ROM (Read Only Memory) 1002 or a program loaded from storage device 1003 into RAM (Random Access Memory) 1004. RAM 1004 also stores various programs and data required for the operation of the project change processing device. The processing unit 1001, ROM 1002, and RAM 1004 are interconnected via bus 1005. Input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input devices 1007 including, for example, touch screens, touchpads, keyboards, mice, image sensors, microphones, accelerometers, gyroscopes, etc.; output devices 1008 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 1003 including, for example, magnetic tapes, hard disks, etc.; and communication devices 1009. Communication device 1009 allows the project change processing equipment to communicate wirelessly or wiredly with other devices to exchange data. Although the figure shows a project change processing equipment 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.

[0088] 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 ROM 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.

[0089] The project change processing device provided in this application, employing the project change processing method described in the above embodiments, can improve upon existing technologies where code analysis tools only analyze code quality and lack a business impact perspective. Furthermore, due to the numerous factors influencing API changes, existing analysis tools struggle to analyze comprehensive technical issues. Compared to existing technologies, the beneficial effects of the project change processing device provided in this application are the same as those of the project change processing method described in the above embodiments, and other technical features of this project change processing device are identical to those disclosed in the previous embodiment method, and will not be elaborated upon here.

[0090] 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.

[0091] The above are merely specific embodiments 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.

[0092] 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 project change processing method described in the above embodiments.

[0093] 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, 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, 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.

[0094] The aforementioned computer-readable storage medium may be included in the project change processing equipment; or it may exist independently and not be assembled into the project change processing equipment.

[0095] The aforementioned computer-readable storage medium carries one or more programs. When these programs are executed by the project change processing device, the project change processing device performs the following actions: acquires information comparing the production and development versions of each resource under the target project; performs database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the production and development version comparison information, and obtains change analysis results; performs association mapping on each change list in the change analysis results based on a preset change impact association engine, and obtains association mapping results; and removes and merges duplicate items in the association mapping results to determine the overall change data for the project.

[0096] 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).

[0097] 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, may 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.

[0098] 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.

[0099] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., computer programs) for executing the above-described project change processing method. This improves upon existing technologies where code analysis tools only analyze code quality and lack a business impact perspective. Furthermore, due to the numerous factors influencing API changes, existing analysis tools struggle to analyze comprehensive technical issues. Compared to existing technologies, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the project change processing method provided in the above embodiments, and will not be elaborated upon here.

[0100] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the project change processing method described above.

[0101] The computer program product provided in this application improves upon existing code analysis tools that only analyze code quality and lack a business impact perspective. Furthermore, due to the numerous factors influencing API changes, existing analysis tools struggle to analyze comprehensive technical issues. Compared to existing technologies, the beneficial effects of the computer program product provided in this application are the same as those of the project change handling method provided in the above embodiments, and will not be elaborated upon here.

[0102] The above are only some embodiments of this application and do 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 handling project changes, characterized in that, The project change handling methods include: Obtain information comparing the production and development versions of each resource under the target project; Based on the comparison information between the production version and the development version, database change analysis, code change impact analysis, SDK change analysis, and platform configuration change analysis are performed to obtain change analysis results. Based on the preset change impact correlation engine, the change list in the change analysis results is correlated and mapped to obtain the correlation mapping results; Duplicate items in the association mapping results are deduplicated and merged to determine the panoramic data of project changes.

2. The method as described in claim 1, characterized in that, The process of obtaining the comparison information between the production version and the development version of each resource under the target project includes: Retrieve the application version list and database version list associated with the project number from the configuration management system; Based on the application version list, obtain the code version tag for each associated application. The code version tag by default includes the production version tag and the latest version tag that is the same as the production version branch. Based on the database version list, obtain the version snapshot, modified data tables, and index version for each database; The configuration version of the application is obtained from the configuration management system based on the application version list; Based on the code version tag, the database version snapshot, and the configuration version, the comparison information between the production version and the development version is determined.

3. The method as described in claim 2, characterized in that, The analysis, based on the comparison information between the production and development versions, includes database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis to obtain change analysis results, including: Based on the comparison information between the production version and the development version, a database change analysis was performed to obtain the database change analysis results. Based on the comparison information between the production version and the development version, an impact analysis of code changes was performed to obtain the results of the impact analysis of code changes. Based on the comparison information between the production version and the development version, SDK change analysis is performed to obtain SDK change analysis results; Based on the comparison information between the production version and the development version, a platform configuration change analysis was performed to obtain the platform configuration change analysis results. The change analysis results are determined based on the database change analysis results, the code change impact analysis results, the SDK change analysis results, and the platform configuration change analysis results.

4. The method as described in claim 3, characterized in that, The database change analysis based on the comparison information between the production version and the development version, to obtain the database change analysis results, includes: The database structure of the current development version is compared with the version actually deployed in the production environment to obtain version comparison results; Based on the version comparison results, extract the database differences and custom SQL scripts to obtain a database change list; The database change analysis results are determined based on the database change list.

5. The method as described in claim 3, characterized in that, The code change impact analysis based on the comparison information between the production version and the development version, and the resulting code change impact analysis, include: The code hosting platform tags are compared based on the tags of the production version and the latest tags that are the same as the production version branch. The commit record list of the current project is determined based on the tag comparison results. The code parsing tool is determined based on the list of submission records; The code parsing tool is used to parse all API interface definitions in the application, determine the API call chain, and construct a directed API call graph based on the API call chain. In the directed graph of API calls, reverse the search to find the API-affected nodes and determine the list of APIs affected by the code changes; The impact analysis results of the code change are determined based on the list of APIs affected by the code change.

6. The method as described in claim 3, characterized in that, The SDK change analysis results, obtained by analyzing the comparison information between the production and development versions, include: Based on the comparison information between the production version and the development version, SDK call chain analysis is performed to determine the SDK code call path; Determine whether there are any changes to the SDK call based on the SDK code call path; If there is an SDK call change and the SDK code call path is called in the API call chain, then the API is determined to be affected by the SDK change, and a list of APIs affected by the SDK change is determined. If there is an SDK call change and the SDK code call path is not called in the API call chain, then the API is determined to be unaffected by the SDK change. The SDK change analysis results are determined based on the list of APIs affected by the SDK changes.

7. The method according to any one of claims 1-6, characterized in that, The step of performing association mapping on each change list in the change analysis results based on a preset change impact association engine to obtain association mapping results includes: Associate the database difference items in the database change list with the corresponding database versions to obtain the database change association results; Associate the APIs in the API list affected by the code changes with the corresponding code changes to obtain the code change association results; Associate the APIs in the list of APIs affected by the SDK changes with the corresponding SDK changes to obtain the SDK change association results; Associate the configuration change items in the configuration change impact analysis report with the corresponding application version to obtain the platform configuration change association results; Based on the database change association results, the code change association results, the SDK change association results, and the platform configuration change association results, an association mapping result is generated. The association mapping result contains a many-to-many mapping relationship between each change source and the affected resources.

8. The method as described in claim 1, characterized in that, The process of deduplicating and merging duplicates in the association mapping results to determine the overall data of project changes includes: If the same API is affected by multiple changes, the affected records will be merged after deduplication to determine the overall change data of the project. The project change overview data includes a summary of changes by change type and a list of affected APIs.

9. The method as described in claim 6, characterized in that, After deduplicating and merging duplicates in the association mapping results to determine the changed panoramic data for the project, the process further includes: The project's panoramic data is visualized to generate a panoramic display.

10. A project change processing system, characterized in that, The system includes: The version acquisition module is used to obtain information comparing the production and development versions of each resource under the target project. The change analysis module is used to perform database change analysis, code change impact analysis, SDK change parsing, and platform configuration change analysis based on the comparison information between the production version and the development version, and to obtain change analysis results. The change association module is used to perform association mapping on each change list in the change analysis results based on a preset change impact association engine, and obtain the association mapping results; The change association module is also used to remove duplicates and merge duplicates in the association mapping results to determine the panoramic data of project changes.

Images