Business request processing methods, devices, electronic equipment and storage media
By using channel script mapping and hot reloading technology, channel interfaces and business logic are decoupled, enabling fast, stable, and efficient processing of multi-channel access in financial insurance and healthcare business systems. This solves the problems of code redundancy and service restarts caused by strong binding of channel interfaces.
Patent Information
- Application Number
- CN202611468269.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-09-20
- Publication Date
- 2026-11-17
AI Technical Summary
The existing channel access solution has strong binding between different channel interfaces and business logic, resulting in code redundancy. In addition, the service needs to be restarted when accessing new channels or adjusting business logic, which cannot meet the needs of rapid deployment of new requirements.
By matching routes with target channel identifiers through preset channel script mapping relationships, hot-loading target business scripts, and calling domain business services through scenario context objects, a unified entry point for channel requests and decoupling of business logic are achieved, avoiding duplicate coding and service restarts.
It enables rapid activation and stability of multi-channel access, eliminates dependence on system release and deployment, and improves operation and maintenance efficiency and user experience.
Smart Images

Figure CN123115223A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of computer software technology and can be applied to the field of multi-channel access in financial insurance and healthcare business systems. In particular, it relates to a business request processing method, apparatus, electronic device and storage medium. Background Technology
[0002] In financial insurance and healthcare systems, the rapid diversification of business needs presents a dual challenge: a surge in business volume and a dramatic increase in demand for multi-channel access. Unified and efficient access to these heterogeneous channels is fundamental to agile business expansion and improved user experience. Currently, the industry typically employs a traditional one-channel-one-interface development model when handling such channel access. Adding a new channel requires developing a dedicated interface, accompanied by a large amount of repetitive coding, or introducing complex, heavyweight gateway middleware for routing and distribution.
[0003] The inventors realized that when faced with the need for rapid business expansion and iteration, related technologies often tightly bind different channel interfaces to business logic, resulting in fragmented interfaces, redundant code, and compatibility issues. Furthermore, each time a new channel is integrated or business logic is adjusted, it requires packaging, deployment, and service restart. This approach not only affects the stability of existing business operations but also significantly increases operational costs, failing to meet the technical requirements for rapidly deploying new channels and meeting new demands in complex business systems. Summary of the Invention
[0004] This invention provides a business request processing method, apparatus, electronic device, and storage medium to solve the technical problem that existing channel access solutions suffer from code redundancy due to the strong binding of different channel interfaces with business logic, and the inability to meet the technical requirements of quickly deploying new needs when accessing new channels or adjusting business logic.
[0005] To achieve the above objectives, a first aspect of this application provides a business request processing method, the method comprising: Obtain the target service request and extract the target channel identifier and target service parameters from the target service request; Based on the preset channel script mapping relationship and the target channel identifier, the script identifier and version information of the target business script are determined; Based on the script identifier and version information, the corresponding target business script is hot-loaded in a preset script execution environment; The target business parameters are encapsulated into a preset scene context object, and the target business script is called using the scene context object after hot loading. During the execution of the target business script, the target business parameters are processed by calling a preset domain business service through the scene context object, and a business processing result is generated.
[0006] To achieve the above objectives, a second aspect of this application provides a service request processing apparatus, the apparatus comprising: The acquisition module is used to acquire the target service request and extract the target channel identifier and target service parameters from the target service request; The determination module is used to determine the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier; The hot-loading module is used to hot-load the corresponding target business script in a preset script execution environment based on the script identifier and version information. The calling module is used to encapsulate the target business parameters into a preset scene context object, and use the scene context object to call the hot-loaded target business script; The generation module is used to process the target business parameters by calling a preset domain business service through the scene context object during the execution of the target business script, and generate a business processing result.
[0007] To achieve the above objectives, a third aspect of this application provides an electronic device, which includes a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the method described in the first aspect.
[0008] To achieve the above objectives, a fourth aspect of the present application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the method of the first aspect described above.
[0009] In the above-mentioned solution implemented by the business request processing method, device, electronic device, and storage medium, the target business request can be obtained first, and the target channel identifier and target business parameters can be extracted from the target business request; based on the preset channel script mapping relationship and the target channel identifier, the script identifier and version information of the target business script can be determined; based on the script identifier and version information, the corresponding target business script can be hot-loaded in a preset script execution environment; the target business parameters can be encapsulated into a preset scene context object, and the hot-loaded target business script can be called using the scene context object; during the execution of the target business script, the target business parameters can be processed by calling the preset domain business service through the scene context object to generate business processing results. In this application, addressing the development needs of diversified channel access in business systems such as financial insurance and healthcare, the following approach is adopted: First, by matching the pre-defined channel script mapping relationship with the target channel identifier, unified entry requests from different channels can be distributed to the corresponding business logic scripts, decoupling the request receiving layer from the underlying business logic. Then, hot-loading of the target business scripts through the script execution environment ensures that adding new business channels or adjusting business rules only requires updating the dynamic script for real-time effect, eliminating the dependence on system release and deployment in traditional development models. Simultaneously, by using a scenario context object as a unified data transmission carrier to call pre-defined domain business services, parameter encapsulation and core function call chains between different channels are standardized, effectively avoiding redundant coding. Through the synergy of these mechanisms, the technical problems of existing channel access solutions—such as strong binding between different channel interfaces and business logic leading to code redundancy, and the inability to quickly deploy new requirements due to the need to restart services when accessing new channels or adjusting business logic—can be solved. Attached Figure Description
[0010] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the description of the embodiments of the present invention will be briefly introduced below. 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.
[0011] Figure 1 This is a schematic diagram of an application environment for a business request processing method according to an embodiment of the present invention; Figure 2 This is a flowchart of the business request processing method provided in the embodiments of this application; Figure 3 This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 4 This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 5This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 6 This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 7 This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 8 This is another flowchart of the business request processing method provided in the embodiments of this application; Figure 9 This is a schematic diagram of the structure of the service request processing device provided in the embodiments of this application; Figure 10 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention; Figure 11 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation
[0012] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.
[0013] It should be noted that although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. The terms "first," "second," etc., in the specification, claims, and the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.
[0014] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein is for the purpose of describing embodiments of this application only and is not intended to limit this application.
[0015] In financial insurance and healthcare systems, the rapid diversification of business needs presents a dual challenge: a surge in business volume and a dramatic increase in demand for multi-channel access. Unified and efficient access to these heterogeneous channels is fundamental to agile business expansion and improved user experience. Currently, the industry typically employs a traditional one-channel-one-interface development model when handling such channel access. Adding a new channel requires developing a dedicated interface, accompanied by a large amount of repetitive coding, or introducing complex, heavyweight gateway middleware for routing and distribution.
[0016] The inventors realized that when faced with the need for rapid business expansion and iteration, existing solutions often tightly bind different channel interfaces to business logic, resulting in scattered interfaces, redundant code, and compatibility issues. Furthermore, each time a new channel is integrated or business logic is adjusted, it requires packaging, deployment, and service restart. This approach not only affects the stability of existing business operations but also significantly increases operational costs, failing to meet the technical requirements for rapidly deploying new channels and meeting new demands in complex business systems.
[0017] Based on this, the embodiments of this application provide a business request processing method, apparatus, device and storage medium, which aim to solve the technical problem that the strong binding between different channel interfaces and business logic in the existing channel access scheme leads to code redundancy, and that the service needs to be restarted when accessing new channels or adjusting business logic, thus failing to meet the technical problem of rapid deployment of new requirements.
[0018] The service request processing method, apparatus, device, and storage medium provided in this application are specifically described through the following embodiments. First, the service request processing method in this application is described.
[0019] The business request processing method provided in this application embodiment can be applied to, for example, Figure 1In this application environment, the client communicates with the server via a network. The server can obtain the target business request and extract the target channel identifier and target business parameters from it. Based on the preset channel script mapping relationship and the target channel identifier, it queries and determines the script identifier and version information of the target business script. Based on the script identifier and version information, it hot-loads the corresponding target business script in a preset script execution environment. It encapsulates the target business parameters into a preset scene context object and uses the scene context object to call the hot-loaded target business script. During the execution of the target business script, it calls the preset domain business service through the scene context object to process the target business parameters, generate a business processing result, and feeds back the business processing result or the target response data encapsulated based on the business processing result to the client. This application addresses the development needs of agile access to diverse channels in financial insurance, healthcare, and other business systems. First, by matching the pre-defined channel script mapping relationship with the target channel identifier, unified entry requests from different channels are distributed to the corresponding business logic scripts, decoupling the request receiving layer from the underlying business logic. Then, the target business script is hot-loaded through the script execution environment, allowing new business channels or adjustments to business rules to take effect immediately by updating the dynamic script, eliminating the dependence on system release and deployment in traditional development models. Simultaneously, a scenario context object serves as a unified data transmission carrier to call pre-defined domain business services, standardizing parameter encapsulation and core function call chains between different channels, effectively avoiding redundant coding. Through the synergy of these mechanisms, the technical problems of existing channel access solutions—such as strong binding between different channel interfaces and business logic leading to code redundancy, and the need to restart services to quickly implement new requirements when accessing new channels or adjusting business logic—can be solved. The client can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and portable wearable devices. The server can be implemented using a separate server or a server cluster composed of multiple servers. The following detailed description of specific embodiments further illustrates this application.
[0020] Figure 2 This is an optional flowchart of the business request processing method provided in the embodiments of this application. Figure 2 The method may include, but is not limited to, steps S201 to S205.
[0021] Step S201: Obtain the target service request and extract the target channel identifier and target service parameters from the target service request.
[0022] Step S202: Based on the preset channel script mapping relationship and the target channel identifier, determine the script identifier and version information of the target business script.
[0023] Step S203: Based on the script identifier and version information, hot-load the corresponding target business script in the preset script execution environment.
[0024] Step S204: Encapsulate the target business parameters into a preset scene context object, and use the scene context object to call the hot-loaded target business script.
[0025] Step S205: During the execution of the target business script, the target business parameters are processed by calling the preset domain business service through the scene context object, and the business processing result is generated.
[0026] In step S201 of some embodiments, during the operation of business systems such as financial insurance or healthcare, it is often necessary to connect to diverse external business channels, such as emerging online platforms, agent tools, or third-party partner institutions. These external callers will use a unified dynamic interface on the server (e.g., using wildcards @PostMapping(" / The target business request is initiated by the interface layer mapped to the request. This target business request, as the data carrier of a business interaction, is typically transmitted in a standardized network message format, such as POST+JSON. After obtaining the target business request, it is deserialized and its fields are parsed to separate and extract two core dimensions of information: First, the target channel identifier, a unique encoding feature (channel_code) used to distinguish the source channel of the current request, representing the specific business party to which the request belongs. This can be extracted from the request path, request header, or request body. Second, the target business parameters, i.e., the substantive business data payload carried in this request. For example, in a health insurance application scenario, the target business parameters could be the policy information submitted by the user, user information, and the specific insurance coverage parameters. Through this data extraction step, a unified multi-channel request entry point is achieved, reducing interface fragmentation from the source and providing basic data input for subsequent logical decoupling and precise routing.
[0027] Please see Figure 3 In some embodiments, steps S301 to S303 may be included before step S202.
[0028] Step S301: Obtain the channel basic configuration information associated with the target channel identifier from the configuration center. The channel basic configuration information includes the supported business type verification rules.
[0029] Step S302: Cache the channel basic configuration information into the memory database and set the time-to-live for the channel basic configuration information.
[0030] Step S303: Within the lifetime, the legality of the target business parameters is verified using the business type verification rules cached in the memory database.
[0031] In step S301 of some embodiments, after the target channel identifier is extracted from the unified dynamic interface, in order to confirm whether the requester has the corresponding business permissions and legitimate identity, the system does not directly allow the request. Instead, it uses the target channel identifier to connect to the distributed configuration center, using the target channel identifier as an index to obtain the basic channel configuration information of the specific channel from the configuration center. This basic channel configuration information typically defines the basic constraints of the channel, including response format requirements, interface timeout time, and supported business type verification rules. For example, for a new online platform channel, its verification rules may limit the channel to currently only supporting two types of businesses: "policy inquiry" and "health insurance application." By obtaining these rules, data support is provided for subsequent pre-emptive security interception.
[0032] In step S302 of some embodiments, health insurance business often faces a large number of concurrent requests at specific marketing nodes. If each request initiates a remote call to read the configuration center, it will lead to high network I / O overhead and increase the operational burden on the configuration center. To address this, this embodiment introduces a bypass caching mechanism, which synchronously stores the acquired channel basic configuration information (e.g., defining configuration items using a format similar to channel:basic:{channel_code}) in a high-performance in-memory database Redis. Simultaneously, a reasonable lifespan is set for this cached data, such as a 5-minute cache validity period. This mechanism ensures that the channel configuration information can be refreshed periodically while significantly reducing the strong dependence on the underlying configuration center in high-concurrency scenarios.
[0033] In step S303 of some embodiments, when a business request belonging to the same target channel identifier arrives at the system within a set lifetime, the business type verification rule for that channel will be quickly retrieved and read directly from the memory database. Subsequently, the extracted business type verification rule is used to perform standardized legality verification on the target business parameters carried in the current target business request. This verification process includes checking the format specifications of the target business parameters, verifying that key parameters are not empty, and checking whether the current request operation exceeds the authorized support scope of the channel. If the verification fails, it will be directly intercepted at the dynamic interface layer, and an exception will be uniformly captured and an error message returned; if the verification passes, the request is considered legitimate and will be allowed to proceed to the subsequent script routing and hot reloading stages.
[0034] Through steps S301 to S303 described above, this embodiment of the application introduces a pre-emptive security check mechanism based on a configuration center and an in-memory database before script routing and execution occur. This mechanism achieves standardized and unified interception and legality verification of request parameters from various channels, preventing illegal, unauthorized, or incorrectly formatted data from flowing into the backend core business logic layer. Simultaneously, by employing a cache degradation strategy with time-to-live (TTL), the access pressure on the configuration center when dealing with massive concurrent requests from health insurance is alleviated, improving the response efficiency of the unified dynamic interface layer and the overall stability of the system.
[0035] In step S202 of some embodiments, in order to break the strong binding relationship of "one channel, one interface" in the traditional development model, the script routing center pre-establishes a channel script mapping relationship to maintain the mapping association of "channel identifier-script ID-version". This mapping relationship logically builds a bridge between the front-end channel and the specific back-end processing logic. Mathematically, the pre-defined channel script mapping relationship can be defined as a mapping function. Let the extracted target channel identifier be the independent variable. The query matching process can then be represented as: . This refers to the script identifier of the target business script that has been matched. This provides the version information for the script. Through this mapping mechanism, it's possible to accurately locate the target business script responsible for handling the personalized rules of a specific channel, such as an online official website or agent tools, without introducing complex gateway middleware. This could be the latest valid version of a Groovy script. Thus, at the request distribution level, a unified entry point and effective routing of multi-dimensional business logic are achieved solely through a lightweight routing mechanism.
[0036] Please see Figure 4 In some embodiments, steps S401 to S402 may be included before step S202, and correspondingly, step S202 may include, but is not limited to, steps S403 to S404.
[0037] Step S401: In response to the content update request for the target business script, obtain the updated script content and the corresponding new version identifier.
[0038] Step S402: Write the updated script content and the new version identifier into the persistent database, and map and update the preset target pilot channel identifier with the new version identifier in the preset channel script mapping relationship.
[0039] Step S403: If the target channel identifier matches the target pilot channel identifier, then the new version identifier is determined as the version information.
[0040] Step S404: If the target channel identifier does not match the target pilot channel identifier, then the historical stable version associated with the target business script is determined as the version information.
[0041] In step S401 of some embodiments, the target business script refers to program code used to process business logic for a specific channel. A content update request refers to a control instruction aimed at modifying, adding to, or iterating the current business logic. A new version identifier is a unique version code generated to distinguish the script's state before and after modification. Specifically, in scenarios where health insurance business rules change or iterate, relevant personnel can edit and modify existing business logic online using a preset web script editor. When the editing operation is completed and a submission is triggered, the server receives a content update request for the target business script. In response to this request, the server obtains the completed updated script content and generates or assigns a corresponding new version identifier. By assigning an independent version identifier, basic data support is provided for subsequent script version control and rapid rollback operations.
[0042] In step S402 of some embodiments, the persistent database refers to a storage medium used to permanently store business data and configuration information. The target pilot channel identifier is a pre-specified channel feature code used for canary releases or small-scale testing. Specifically, after obtaining the script data, the server stores the updated script content and the new version identifier in the persistent database to retain historical version records, thus avoiding the traceability difficulties and high risks caused by direct overwriting of hard-coded code in related technologies. Simultaneously, to achieve canary release of script rules, certain specific channels (such as a specific agent tool or online platform) are selected as test channels. In the maintained configuration items, the server associates and dynamically updates the preset target pilot channel identifier with the aforementioned new version identifier; this process does not require interruption of the current service.
[0043] In step S403 of some embodiments, when processing actual business requests and performing route matching, the server performs a consistency comparison between the extracted target channel identifier and the configured target pilot channel identifier. If the comparison result is a match, it indicates that the current target business request originates from a pilot channel participating in the gray-scale release test. At this time, the server determines the new version identifier as the corresponding version information based on the updated mapping relationship, so that the request from the pilot channel can be subsequently routed to the new version script for logical processing and rule verification. It should be noted that in the embodiments of this application, if the target business request involves the collection and processing of personal privacy data such as user health disclosure data and policy identity data, personal authorization may be required if necessary.
[0044] In step S404 of some embodiments, the historical stable version refers to an old version identifier that has been fully verified and runs normally in the production environment before this content update. Specifically, during route matching and comparison, if the server finds that the extracted target channel identifier does not match the aforementioned target pilot channel identifier, it indicates that the current target business request originates from a regular channel that did not participate in the canary release. To avoid the new logic causing unknown impacts on existing regular business, the server directly determines the historical stable version currently associated with the target business script as the corresponding version information based on the routing mapping rules. Through this strategy, requests from regular channels continue to be processed by the original stable version script. The above process effectively reduces the trial and error cost of launching new business rules and ensures the overall stability of the existing health insurance business during the agile iteration process.
[0045] Through steps S401 to S404 above, this embodiment first responds to content update requests to persist the target business script of the new version, and establishes an association between the target pilot channel identifier and the new version identifier in the preset channel script mapping relationship; then, when actually processing business requests, it dynamically allocates the new version identifier or the historical stable version based on the comparison result between the target channel identifier and the target pilot channel identifier. Through the above mapping update and version distribution mechanism, some pilot channels can pre-introduce the new version script for business logic verification and trial operation, while the remaining unmatched regular channels continue to maintain the historical stable version without interference. Thus, it is possible to achieve gray-scale release and rapid rollback of script rules without affecting the overall stability of existing regular business, solving the technical problems of high trial and error costs and uncontrollable impact caused by the full coverage approach usually adopted in related technologies for business logic modification and deployment.
[0046] In step S203 of some embodiments, after determining the identity of the script used to process the current channel request, it is necessary to obtain its specific code logic text, i.e., the target business script, from the code repository. This target business script encapsulates the corresponding channel-specific business rules and processes, and can be stored as script code text in a persistent database or application cache. The script code text represents the script content of the target business script. After obtaining this content, it is hot-loaded in a preset script execution engine. Hot loading refers to using dynamic language features, through a dynamic compilation component (such as GroovyShell), to convert the obtained target business script into executable program instructions (such as Java objects) in real time, and loading them into memory for execution, while the business system continues to run without downtime or restart. For example, when the business rules of a cooperating medical institution change, only the corresponding target business script in the database needs to be updated, and the latest script content can be dynamically loaded in real time in the script execution engine through this step. This mechanism achieves a no-release access experience where modifications are immediately deployed, avoiding the cumbersome process of packaging, deployment, and service restart caused by traditional hard-coded code modifications, and ensuring the high availability and stability of the system.
[0047] Please see Figure 5 In some embodiments, step S203 may include, but is not limited to, steps S501 to S504.
[0048] Step S501: Generate the corresponding script cache key-value pair based on the script identifier and version information.
[0049] Step S502: Query the application cache based on the script cache key-value pair. If the cache is hit, obtain the corresponding target business script.
[0050] In step S503, if the cache is not hit, the target business script is read from the persistent database and the target business script is synchronously updated to the application cache.
[0051] Step S504: The target business script is hot-loaded in the script execution environment through a dynamic compilation mechanism.
[0052] In step S501 of some embodiments, the script cache key is an identifier string used to uniquely index and map the data characteristics of a specific version of the business script in the cache space. Specifically, in scenarios where multiple channels of business are running concurrently and different versions of the same script may coexist (such as a gray-scale release test version and a historical stable version), after the server obtains the script identifier `scriptCode` and version information `version` of the target business script output by the front-end routing stage, it constructs a string according to a preset concatenation rule. For example, the server combines the script identifier and version information using a specific connector to generate a unique script cache key such as `ScriptKey` (i.e., `scriptCode` + `version`). By generating this independent cache key containing the version dimension, unique identification and physical isolation of different business channel logics and different versions of scripts within the same channel logic are achieved in the cache area, providing a retrieval basis for subsequent independent caching and scheduling of multiple version scripts.
[0053] In step S502 of some embodiments, the application cache refers to a temporary storage medium deployed on the server's local machine or in distributed memory for high-speed access to frequently accessed business data. Specifically, businesses such as health insurance often experience massive concurrent requests at specific marketing nodes. If each script scheduling requires retrieval and compilation of underlying data, it would consume enormous computing resources. Therefore, the server uses the generated script cache key as the search keyword to initiate a fast query request to the application cache (such as high-performance memory components like Redis). If a valid data block matching the search keyword exists in the application cache, a cache hit occurs. The server directly extracts and retrieves the corresponding target business script, i.e., the written script code logic text, from the corresponding location in the application cache. This method of directly extracting script data from the high-speed application cache significantly reduces the overhead of cross-network or cross-disk queries and the computational consumption of repeated compilation.
[0054] In step S503 of some embodiments, the persistent database refers to a data storage system used to store the details and version history of various business script codes in a long-term and stable manner. Specifically, if the server does not find the corresponding script record in the application cache, or if the cached data has exceeded the preset cache expiration time (e.g., a 5-minute validity period) and is cleared, i.e., a cache miss occurs, the server will use the script identifier and version information to send a query command to the persistent database to read the corresponding target business script. After obtaining this content, the server synchronously writes it back to the application cache as new hot data and binds it with the script cache key-value generated in step S501. Through this design of local caching combined with a persistent database, the persistence and manageability of the script state are ensured, and subsequent business requests carrying the same version information can directly hit the cache.
[0055] In step S504 of some embodiments, the dynamic compilation mechanism refers to the mechanism that, during program execution, utilizes the characteristics of dynamic languages to compile the source code text of script code into an executable object in real time.
[0056] Specifically, after obtaining the latest valid and corresponding version of the target business script, the server calls the corresponding dynamic compilation component GroovyShell within the preset script execution engine. Leveraging the seamless compatibility between the Groovy scripting language and the underlying environment (such as Java), the server compiles the script code text written in the dynamic language into an executable object (such as a Java object) that can be directly recognized and invoked by the virtual machine in real time. After compilation, the server directly loads the program object into the runtime memory for execution. Throughout the hot reloading process, the server can continuously accept new business requests without the need for traditional service packaging, release deployment, or service restart operations, enabling the channel access business logic to take effect immediately.
[0057] Through steps S501 to S504 described above, this embodiment first constructs a unique script cache key-value pair by combining the script identifier and version information. Based on this, a multi-level read and state synchronization mechanism is established between the application cache and the persistent database. Then, after obtaining the script content, a dynamic compilation component is used to load it into memory. Through these technical means, the reading of multiple versions of scripts can be completed independently and preferentially in the high-speed application cache, while simultaneously and seamlessly converting text code into executable objects in real time. This significantly reduces the data read load and repetitive compilation overhead of the system under massive concurrency, while ensuring the coexistence of multiple versions of business scripts and real-time hot loading.
[0058] Please see Figure 6 In some embodiments, the target business script includes a variety of preset script language types, and step S203 may include, but is not limited to, steps S601 to S603.
[0059] Step S601: Parse the script language type identifier carried by the target business script.
[0060] Step S602: Select a matching target language executor from a set of preset language executors based on the script language type identifier.
[0061] Step S603: Use the target language executor to hot-load the target business script in the script execution environment.
[0062] In step S601 of some embodiments, the target business script refers to dynamic business logic code that encompasses multiple preset programming language possibilities, and the script language type identifier refers to a feature tag indicating the specific programming language used by the current script code. Specifically, to accommodate the channel requirements of different technology stacks, after obtaining the target business script, the server reads and parses the metadata attributes or code header information of the script content. The server extracts the script language type identifier corresponding to the target business script through the file extension, configuration attribute file, or feature tags carried in the script message header, thereby clarifying the specific language category of the current script.
[0063] In step S602 of some embodiments, the language executor is a low-level component pre-configured within the server, capable of parsing, compiling, and running for a specific programming language. The target language executor is a specific component corresponding to the current script language type and capable of correctly compiling the current script content. Specifically, the server internally pre-configures an executor set containing multiple different language executors, each language executor responsible for supporting the dynamic language compilation of its corresponding technology stack. The server uses the extracted script language type identifier as a matching condition to search among the pre-configured multiple language executors. When a language executor matching the script language type identifier is found, the server selects and instantiates it as the target language executor specifically for processing the current script content.
[0064] In step S603 of some embodiments, after the server identifies a matching target language executor, it calls the core compilation interface of that executor within a preset script execution environment. The target language executor dynamically compiles the text-based target business script into a program object that can be directly recognized and executed by the underlying virtual machine, according to its corresponding language syntax rules. After compilation, the server loads this object into runtime memory to prepare for business calls. The entire process is continuous and real-time, without interrupting the processing of other business operations in the current system.
[0065] Through steps S601 to S603 described above, this embodiment first parses the language type identifier carried in the script content, then dynamically routes and selects a matching target language executor from a pre-set executor set, and finally uses this dedicated executor to complete the hot-loading compilation of multi-language scripts. This mechanism design decouples the server-side script execution environment from the limitations of a single programming language, enabling it to support the dynamic compilation and execution of multiple scripting language types simultaneously. This allows for flexible adaptation to the technical stack requirements of various external channels, solving the technical problems of poor scalability and high technical compatibility costs caused by the high dependence on a single programming language in related technologies for channel access solutions.
[0066] Please see Figure 7 In some embodiments, after step S203, steps S701 to S703 may be included, but are not limited to.
[0067] Step S701: Obtain the resource call volume and execution time of the target business script in the script execution environment in real time.
[0068] Step S702: If the resource call volume is detected to exceed the preset resource access permission threshold, the current execution process is interrupted and a resource over-limit abnormal alarm message is output.
[0069] Step S703: If the execution time is detected to have reached the preset script execution time threshold, the current execution process is interrupted and an execution timeout error alarm is output.
[0070] In step S701 of some embodiments, resource call volume refers to the measurement data of the underlying computing resources occupied by the target business script during its execution, such as memory allocation and the number of threads. Execution duration refers to the length of time elapsed from when the target business script is triggered to the current moment. Specifically, after the server hot-loads the target business script and triggers its execution, to prevent potential risks such as infinite loops or memory leaks in the dynamically injected script code, the server continuously tracks the running status of the target business script in the isolated script execution sandbox environment through an internal monitoring component. The server collects and obtains the resource call volume currently consumed by the target business script in real time, and records its cumulative execution duration, providing real-time data support for subsequent anomaly detection and circuit breaker interception.
[0071] In step S702 of some embodiments, the preset resource access permission threshold is the maximum allowed resource consumption limit allocated to a single script execution task. The resource over-limit anomaly alarm information is notification data generated to indicate an abnormal state when a script excessively consumes resources in violation of regulations. Specifically, the server compares the real-time collected resource call volume with the preset resource access permission threshold. Once it is detected that the resource call volume consumed by the current target business script exceeds the security boundary set by the threshold, it indicates that the script logic may have a serious defect and is excessively occupying the host's computing resources. At this time, the server will forcibly block the current execution flow of the target business script and encapsulate and generate a resource over-limit anomaly alarm information. This alarm information can be further pushed to a specific monitoring panel or alarm communication group for relevant maintenance personnel to investigate.
[0072] In step S703 of some embodiments, the preset script execution duration threshold is the longest tolerable time boundary set for the script execution task, such as a default execution time limit of 5 seconds. The execution timeout exception alarm information is an error alarm signal generated for scripts that have run for too long. Specifically, during real-time monitoring of execution duration, the server continuously compares the current execution duration with the preset script execution duration threshold. If the execution duration of the target business script reaches or exceeds the preset script execution duration threshold, it indicates that the script may have entered a logical infinite loop or experienced a long-term blockage due to calling an external interface. To ensure that the core threads of the business system are not overwhelmed by a large number of pending single time-consuming channel requests, the server will trigger a circuit breaker mechanism, forcibly interrupting the current execution flow of the target business script and simultaneously outputting the execution timeout exception alarm information.
[0073] Through steps S701 to S703 described above, this embodiment of the application introduces a dual-dimensional monitoring and interception mechanism based on the script execution environment, encompassing both resources and time, during the execution of the target business script. By acquiring resource call volume and execution duration in real time and comparing them with corresponding preset thresholds, abnormal script usage or execution blocking can be forcibly blocked in a timely manner, and abnormal alarm information can be output. This ensures the flexibility of hot-loading dynamic scripts across multiple channels while strictly limiting script execution permissions and resource usage, effectively preventing abnormal script logic from affecting the operation of core services. It solves the technical problem in related technologies where excessive dynamic code execution permissions and a lack of effective isolation and monitoring lead to poor overall system stability.
[0074] In step S204 of some embodiments, to standardize the messy parameter transmission methods between different channels and achieve data and logic isolation, this embodiment introduces a process context abstraction mechanism, using a scenario context object (such as a sub-scenario context transformed by extending the abstractContext parent class) as a data bus and interaction medium. Target business parameters extracted in step S201, such as policy information and user information, are uniformly assembled and encapsulated into this preset scenario context object. This scenario context object shields the specific form of the underlying network request, providing a standardized data access environment for script execution. Subsequently, this scenario context object is used as a trigger credential and parameter carrier, input to the execution entry point of the hot-loaded target business script, thereby waking up and driving the target business script to begin executing specific business rule flows. By automatically passing request information and dependent services through the context, the script writing logic is simplified.
[0075] Please see Figure 8 In some embodiments, step S204 may include, but is not limited to, steps S801 to S804.
[0076] Step S801: Construct an abstract context parent class and configure the script identifier, version information, target channel identifier, and domain service loader in the abstract context parent class.
[0077] Step S802: Based on the type of the current business scenario, convert the abstract context parent class into the corresponding scenario subclass context object.
[0078] Step S803: Inject the target business parameters into the scene subclass context object to obtain the configured scene context object.
[0079] Step S804: Use the scene context object to trigger the hot-loaded target business script so that the target business script can dynamically inject domain business services based on the domain service loader when it is executed.
[0080] In step S801 of some embodiments, the abstract context parent class refers to the basic data carrier and dependency transitive class extracted and constructed to adapt to various business processes. The domain service loader is a service bridge proxy that encapsulates the calling capabilities of the underlying core business components. Specifically, in order to achieve the context multi-scenario adaptation function, the server constructs this abstract context parent class in the code framework. The server uniformly defines and configures core fields in this parent class, mainly including: a unique script identifier (scriptCode) bound to a specific channel, a script version (scriptVersion) that supports canary release and rollback control, a target channel identifier (channelCode) that associates the "channel-script" mapping relationship, and a domain service loader used to support the dynamic injection of underlying core Bean objects in the script.
[0081] In step S802 of some embodiments, the target business parameter further includes a business scenario type identifier that characterizes the business scenario to which the current target business request belongs. The server can determine the current business scenario type based on the business scenario type identifier. The business scenario type refers to the specific business flow link to which the current request belongs, such as the application acceptance process or the monitoring business event consumption feedback channel process in the core scenario of health insurance. The scenario subclass context object is a data entity that inherits from the abstract context parent class and extends exclusive fields for a specific business scenario. Specifically, the health insurance business covers many sub-scenarios. The server determines the scenario subclass corresponding to the current business scenario type based on the current business scenario type in the target business parameter. The scenario subclass inherits the common attributes defined in the abstract context parent class and instantiates the scenario subclass context object based on the scenario subclass, so that the script identifier, version information, target channel identifier, and domain service loader in the abstract context parent class are carried in the scenario subclass context object. The process of converting the abstract context parent class into the corresponding scenario subclass context object includes the process of determining the corresponding scenario subclass based on the inheritance relationship between the abstract context parent class and the scenario subclass and forming the corresponding scenario subclass context object. For example, when processing the application acceptance process, the server converts it into an AcceptScriptContext; when processing the business event consumption process, it converts it into a ConsumerScriptContext.
[0082] In step S803 of some embodiments, the configured scenario context object refers to a runtime context instance that loads complete business data and underlying service call references. Specifically, after the server obtains the instantiated scenario subclass context object, it assembles and automatically injects the target business parameters obtained in the early parsing according to the exclusive fields defined by the subclass. For example, for the acceptance script context, the server will assemble the channel code, request parameter mapping table (Map...<String,Object> The request and the set of parameters to be passed in the process are injected into the context; for the business consumption script context, the corresponding message topic, message tag, and request parameter message content fields are injected. After the above parameter assignment is completed, the server obtains the configured scenario context object.
[0083] In step S804 of some embodiments, the domain business service refers to the underlying core business capability components that are pre-developed and deployed on the server side, such as core business beans like insurance application services, claims services, policy query models, or premium calculation services. Specifically, the server passes the configured scenario context object as an execution parameter to the script execution engine, thereby triggering the hot-loaded target business script to start running. During script execution, the script logic does not need to concern itself with the underlying request parsing mechanism or cumbersome service dependency configuration, but directly extracts the domain service loader carried in the scenario context object. The server enables the target business script to dynamically obtain and inject the required domain business services based on the domain service loader, and then call these core business services to complete specific business operations and logic processing.
[0084] Through steps S801 to S804 above, this embodiment first constructs an abstract context parent class containing core identifiers and domain service loaders, and then converts it into a scenario subclass context object according to specific business scenarios to inject business parameters. Finally, this context object is used to drive the execution of hot-loading scripts and dynamically inject core services. Through the above-mentioned process context abstraction mechanism, the server can automatically transmit request information and dependent services, realizing a seamless bridge between personalized scripts for specific channels and the underlying core components of the domain. This simplifies the writing logic of target business scripts, allowing script developers to focus only on core business logic, further improving development efficiency, and solving the technical problem in related technologies that the channel access development process needs to handle a large amount of repetitive coding and complex service dependencies.
[0085] In step S205 of some embodiments, the target business script is mainly responsible for orchestrating channel-specific business rules, such as determining access conditions for specific channels, rather than repeatedly implementing the core computing capabilities of the underlying system. When the target business script runs in the execution environment, it uses the passed-in scenario context object to initiate calls to the lower layer, triggering preset domain business services in the system kernel. The scenario context object abstractly encapsulates a domain service loader, supporting the dynamic injection of core business into the script. These domain business services are typically core business capability components in financial insurance systems, such as core policy query models, premium calculation services, or policy services. The domain business service receives and processes the target business parameters in the scenario context object, completes professional domain calculations, and returns the calculation results to the engine where the target business script resides. Finally, it integrates and generates the business processing result for this target business request, effectively separating the channel personalization logic from the underlying core public capabilities.
[0086] Through steps S201 to S205 above, this embodiment first extracts the target channel identifier and parameters from the business requests received by the unified wildcard interface. Based on mathematical mapping relationships, it accurately routes and determines the identity and version of the target business script. Subsequently, it dynamically hot-loads the script content in the script execution engine and uses a scenario context object as a standardized carrier to drive script execution. Finally, it bridges the underlying domain business services through this context object to complete parameter processing. This complete data flow mechanism decouples the channel access layer, personalized rule layer, and core capability layer, ensuring that changes in business logic or the access of new channels depend solely on the mapping and hot-loading execution of the target business script. This solves the technical problem in existing channel access solutions where strong binding between different channel interfaces and business logic leads to code redundancy, and where accessing new channels or adjusting business logic requires service restarts, thus failing to meet the technical requirements for rapid deployment of new needs.
[0087] Please see Figure 9 This application embodiment also provides a business request processing apparatus that can implement the above-described business request processing method. The apparatus includes: The acquisition module is used to acquire the target business request and extract the target channel identifier and target business parameters from the target business request; The determination module is used to determine the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier; The hot-loading module is used to hot-load the corresponding target business script in a preset script execution environment based on the script identifier and version information. The calling module is used to encapsulate the target business parameters into a preset scene context object, and use the scene context object to call the hot-loaded target business script; The generation module is used to process the target business parameters and generate business processing results by calling a preset domain business service through the scene context object during the execution of the target business script.
[0088] In some embodiments, the module is invoked specifically for: Construct an abstract context parent class and configure the script identifier, version information, target channel identifier, and domain service loader in the abstract context parent class; Based on the type of the current business scenario, the abstract context parent class is converted into the corresponding scenario subclass context object; Inject the target business parameters into the scene subclass context object to obtain the configured scene context object; The target business script is triggered by hot reloading using the scene context object, so that the target business script can dynamically inject domain business services based on the domain service loader when it is executed.
[0089] In some embodiments, the hot-loading module is specifically used for: Generate corresponding script cache key-value pairs based on script identifier and version information; The application cache is queried based on the script cache key-value pair. If the cache is hit, the corresponding target business script is retrieved. If the cache is not hit, the target business script is read from the persistent database and then synchronously updated to the application cache. The target business script is hot-loaded in the script execution environment through a dynamic compilation mechanism.
[0090] In some embodiments, the generation module is further configured to: Real-time acquisition of resource usage and execution time of the target business script in the script execution environment; If the resource access volume is detected to exceed the preset resource access permission threshold, the current execution process will be interrupted and a resource over-limit alarm message will be output. If the execution time is detected to have reached the preset script execution time threshold, the current execution process will be interrupted and an execution timeout error alarm message will be output.
[0091] In some embodiments, the determining module is further configured to: In response to a content update request for a target business script, obtain the updated script content and the corresponding new version identifier; Write the updated script content and new version identifier to the persistent database, and update the preset target pilot channel identifier with the new version identifier in the preset channel script mapping relationship; Correspondingly, if the target channel identifier matches the target pilot channel identifier, the new version identifier will be identified as the version information; If the target channel identifier does not match the target pilot channel identifier, the historical stable version associated with the target business script will be used as the version information.
[0092] In some embodiments, the target business script includes multiple preset scripting language types, and the hot-loading module is further used for: Parse the script language type identifier carried by the target business script; Based on the script language type identifier, select the matching target language executor from a set of pre-defined language executors; The target language executor is used to hot-load the target business script in the script execution environment.
[0093] In some embodiments, the determining module is further configured to: Obtain the basic channel configuration information associated with the target channel identifier from the configuration center. The basic channel configuration information includes the validation rules for the supported business types. Cache the channel basic configuration information in an in-memory database and set a time-to-live for the channel basic configuration information; During the lifetime, the legality of the target business parameters is verified using the business type validation rules cached in the in-memory database.
[0094] This invention provides a business request processing device. First, by matching and routing pre-defined channel script mapping relationships with target channel identifiers, it distributes unified entry requests from different channels to corresponding business logic scripts, decoupling the request receiving layer from the underlying business logic. Then, it hot-loads the target business script through a script execution environment, allowing new business channels or adjustments to business rules to take effect instantly by simply updating the dynamic script, eliminating the dependence on system releases and deployments in traditional development models. Simultaneously, it uses a scenario context object as a unified data transmission carrier to call pre-defined domain business services, standardizing parameter encapsulation and core function call chains between different channels, effectively avoiding redundant coding. Through the synergy of these mechanisms, it solves the technical problems of existing channel access solutions where strong binding between different channel interfaces and business logic leads to code redundancy, and where accessing new channels or adjusting business logic requires service restarts, thus failing to meet the technical requirements for rapid deployment of new needs.
[0095] For specific limitations regarding the business request processing device, please refer to the limitations on the business request processing method above, which will not be repeated here. Each module in the aforementioned business request processing device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in the computer device in hardware form, or stored in the memory of the computer device in software form, so that the processor can call and execute the operations corresponding to each module.
[0096] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 10 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The network interface is used to communicate with external clients via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a business request processing method on the server side.
[0097] In one embodiment, a computer device is provided, which may be a client, and its internal structure diagram may be as follows: Figure 11As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The network interface is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements a client-side function or step based on a business request processing method.
[0098] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps: Obtain the target business request and extract the target channel identifier and target business parameters from the target business request; Based on the preset channel script mapping relationship and the target channel identifier, determine the script identifier and version information of the target business script; Based on the script identifier and version information, the corresponding target business script is hot-loaded in the preset script execution environment; The target business parameters are encapsulated into a preset scene context object, and the scene context object is used to call the hot-loaded target business script; During the execution of the target business script, the preset domain business service is called through the scene context object to process the target business parameters and generate the business processing result.
[0099] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and client side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.
[0100] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), RAMbus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.
[0101] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.
[0102] It should be noted that any AI models, software tools, or components not belonging to this company appearing in the embodiments of this application are merely illustrative examples and do not represent actual use. All user personal information involved in the embodiments of this application has been authorized (with the knowledge and consent) by the relevant parties or has been fully authorized by all parties, and the executing entity may obtain it through various legal and compliant means. The collection, storage, use, processing, transmission, provision, and disclosure of the information, data, and signals involved all comply with relevant laws and regulations and do not violate public order and good morals.
[0103] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.
Claims
1. A business request processing method, characterized in that, include: Obtain the target service request and extract the target channel identifier and target service parameters from the target service request; Based on the preset channel script mapping relationship and the target channel identifier, the script identifier and version information of the target business script are determined; Based on the script identifier and version information, the corresponding target business script is hot-loaded in a preset script execution environment; The target business parameters are encapsulated into a preset scene context object, and the target business script is called using the scene context object after hot loading. During the execution of the target business script, the target business parameters are processed by calling a preset domain business service through the scene context object, and a business processing result is generated.
2. The business request processing method according to claim 1, characterized in that, The step of encapsulating the target business parameters into a preset scene context object and using the scene context object to call the hot-loaded target business script includes: Construct an abstract context parent class, and configure the script identifier, version information, target channel identifier, and domain service loader in the abstract context parent class; Based on the current business scenario type in the target business parameters, the abstract context parent class is converted into the corresponding scenario subclass context object; The target business parameters are injected into the scene subclass context object to obtain the configured scene context object; The target business script is triggered by hot reloading using the scenario context object, so that the target business script dynamically injects the domain business service based on the domain service loader during execution.
3. The business request processing method according to claim 1, characterized in that, The step of hot-loading the corresponding target business script in a preset script execution environment based on the script identifier and version information includes: Generate a corresponding script cache key-value pair based on the script identifier and the version information; Based on the script cache key-value query, if the application cache is hit, the target business script corresponding to the script cache key is obtained. If the cache is not hit, the target business script is read from the persistent database and the target business script is synchronously updated to the application cache. The target business script is hot-loaded in the script execution environment using a dynamic compilation mechanism.
4. The business request processing method according to claim 1, characterized in that, After hot-loading the corresponding target business script in a preset script execution environment based on the script identifier and version information, the method further includes: Real-time acquisition of the resource call volume and execution time of the target business script in the script execution environment; If the resource call volume is detected to exceed the preset resource access permission threshold, the current execution process will be interrupted and a resource over-limit alarm message will be output. If the execution time is detected to have reached the preset script execution time threshold, the current execution process is interrupted and an execution timeout error alarm is output.
5. The business request processing method according to claim 1, characterized in that, Before querying and determining the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier, the method further includes: In response to a content update request for the target business script, obtain the updated script content and the corresponding new version identifier; The updated script content and the new version identifier are written to the persistent database, and the preset target pilot channel identifier is mapped and updated with the new version identifier in the preset channel script mapping relationship; Accordingly, the step of querying and determining the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier includes: If the target channel identifier matches the target pilot channel identifier, then the new version identifier is determined as the version information; If the target channel identifier does not match the target pilot channel identifier, then the historical stable version associated with the target business script will be determined as the version information.
6. The business request processing method according to claim 1, characterized in that, The target business script includes multiple preset script language types. The hot loading of the corresponding target business script in a preset script execution environment based on the script identifier and version information includes: Parse the script language type identifier carried by the target business script; Based on the script language type identifier, select a matching target language executor from a set of preset language executors; The target language executor is used to hot-load the target business script in the script execution environment.
7. The business request processing method according to claim 1, characterized in that, Before querying and determining the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier, the method further includes: Obtain the channel basic configuration information associated with the target channel identifier from the configuration center. The channel basic configuration information includes the supported service type verification rules. The channel basic configuration information is cached in an in-memory database, and a time-to-live (TTL) is set for the channel basic configuration information. During the specified lifetime, the legality of the target business parameters is verified using the business type verification rules cached in the memory database.
8. A service request processing apparatus, characterized in that, The device includes: The acquisition module is used to acquire the target service request and extract the target channel identifier and target service parameters from the target service request; The determination module is used to determine the script identifier and version information of the target business script based on the preset channel script mapping relationship and the target channel identifier; The hot-loading module is used to hot-load the corresponding target business script in a preset script execution environment based on the script identifier and version information. The calling module is used to encapsulate the target business parameters into a preset scene context object, and use the scene context object to call the hot-loaded target business script; The generation module is used to process the target business parameters by calling a preset domain business service through the scene context object during the execution of the target business script, and generate a business processing result.
9. An electronic device, characterized in that, The electronic device includes a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the service request processing method according to any one of claims 1 to 7.
10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the business request processing method according to any one of claims 1 to 7.
