Data processing method and device, storage medium and electronic equipment

Abstract

The application discloses a data processing method and device, a storage medium and an electronic device. The method comprises the following steps: acquiring a target function set when a target client is in a running state; generating a target linked list associated with a target software development kit according to the target function set; in response to a function request message of the target client, capturing a target function by using a target node, and processing initial data parameters passed in the target function into target data parameters in a preset format. The application can be applied to technical scenes including but not limited to data caching, data reading and the like, and solves the technical problem of low efficiency of a software development kit in processing data in the related art.

Description

Technical Field

[0001] This application relates to the field of computers, and more specifically, to a data processing method and apparatus, a storage medium, and an electronic device. Background Technology

[0002] Currently, when a client executes a specific function of the SDK (Software Development Kit), it retrieves data by sending a request. After receiving the response from the server, the client performs operations such as parsing, loading, and caching.

[0003] Because different SDKs belong to different companies, development teams, and use different servers, each SDK caches data on the client's disk. This can lead to excessive resource consumption and lag on some devices with limited storage space, resulting in low efficiency in data processing by the SDK.

[0004] There is currently no effective solution to the above problems. Summary of the Invention

[0005] This application provides a data processing method and apparatus, a storage medium and an electronic device to at least solve the technical problem of low efficiency in data processing by software development kits in related technologies.

[0006] According to one aspect of the embodiments of this application, a data processing method is provided, comprising: when a target client is in a running state, obtaining a target function set, wherein the target function set is a set of functions called by the target client through a target software development kit; generating a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set; responding to a function request message from the target client, capturing target functions using target nodes, and processing the initial data parameters passed in the target functions into target data parameters of a preset format, wherein the target linked list includes the target nodes, the target nodes correspond to the target functions, the function request message is used to request the invocation of the target functions, and the preset format represents a uniform data format pre-set for software development kits allowed to be used by the target client.

[0007] According to another aspect of the embodiments of this application, a data processing apparatus is also provided, comprising: an acquisition module, configured to acquire a set of target functions when a target client is in a running state, wherein the set of target functions is a set of functions called by the target client through a target software development kit; a generation module, configured to generate a target linked list associated with the target software development kit based on the set of target functions, wherein the nodes in the target linked list correspond one-to-one with the functions in the set of target functions; and a processing module, configured to, in response to a function request message from the target client, capture target functions using target nodes and process the initial data parameters passed in the target functions into target data parameters of a preset format, wherein the target linked list includes the target nodes, the target nodes correspond to the target functions, the function request message is used to request the invocation of the target functions, and the preset format represents a uniform data format pre-set for software development kits allowed to be used by the target client.

[0008] Optionally, the device is further configured to: pre-set multiple sets of functions to be captured before the target client is in the running state, wherein the multiple sets of functions include sets of functions corresponding to multiple software development kits allowed by the target client, one software development kit is mapped to one set of functions, and the multiple sets of functions include the target set of functions; the device is configured to generate a target linked list based on the target set of functions by: traversing each set of functions in the multiple sets of functions and creating a set of linked lists, wherein one linked list in the set of linked lists has a one-to-one correspondence with one set of functions in the multiple sets of functions, one node in one linked list has a one-to-one correspondence with one function in one set of functions, and the set of linked lists includes the target linked list.

[0009] Optionally, the device is configured to traverse each of the plurality of function sets to create a linked list by: traversing the target function set to create the target linked list by: creating an initial linked list and setting a target pointer, wherein the target pointer is set to point to the first function in the target function set; modifying the movement address of the target pointer to extract functions in the target function set sequentially; generating a node with a target identifier for each function in the target function set, and creating the target linked list, wherein the target identifier is used to indicate that the target linked list is associated with the target software development kit.

[0010] Optionally, the apparatus is configured to respond to the function request message from the target client by capturing the target function using a target node and processing the initial data parameters passed in the target function into target data parameters of a preset format in the following manner: In response to the function request message from the target client, if the function request message indicates a request to write the target data parameters, the apparatus controls the target software development kit to call the target function, captures the target function using the target node, and processes the initial data parameters into the target data parameters; the apparatus is further configured to: In response to the function request message from the target client, if the function request message indicates a request to read the target data parameters, control the target software development kit to call the target function, access the target node, and read the target data parameters, wherein the target function has been captured during the writing process.

[0011] Optionally, the apparatus is further configured to: perform an initialization operation on the environment variables when the target function is called during the process of capturing the target function using the target node, and determine the target environment variables; determine the data type of the target data parameters according to the target environment variables; and create a first thread according to the data type, wherein the first thread is configured to process the initial data parameters into the target data parameters.

[0012] Optionally, the apparatus is further configured to: after creating a corresponding first thread according to the data type, load the initial data parameters into the first thread and convert them into the target data parameters; store the target data parameters in the target terminal where the target client is located, wherein the target terminal is used to store data parameters corresponding to different software development kits that the target client is allowed to call.

[0013] Optionally, the device is used to load the initial data parameters into the first thread and convert them into the target data parameters by: loading the initial data parameters into the first thread and adding a mutex lock, wherein the mutex lock is used to indicate that the initial data parameters are prohibited from being modified by a second thread during the conversion into the target data parameters, and the second thread is different from the first thread; and deleting the mutex lock after the initial data parameters have been converted into the target data parameters.

[0014] Optionally, the apparatus is further configured to: after loading the initial data parameters into the first thread and converting them into the target data parameters, when the function request message indicates a request to write the target data parameters, perform an encoding operation on the target data parameters to obtain a first data parameter; when the function request message indicates a request to read the target data parameters, perform a decoding operation on the first data parameters to obtain the target data parameters, wherein the decoding operation corresponds to the encoding operation.

[0015] Optionally, the apparatus is further configured to: when the function request message is used to request the acquisition of business data, send a target classification identifier to the proxy server, wherein the target classification identifier is used to identify the account type of the first account, the first account is the account that logs into the target client, the proxy server pre-classifies multiple accounts and assigns different classification identifiers to accounts of different account types among the multiple accounts, the multiple accounts including the first account; when the proxy server has cached the target business data, receive the target business data returned by the proxy server, wherein the target business data is the business data requested by the second account that logs into the target client through the target software development kit, the second account has the same account type as the first account, and the multiple accounts include the second account.

[0016] According to another aspect of the embodiments of this application, a computer-readable storage medium is also provided, wherein a computer program is stored in the computer-readable storage medium, and the computer program is configured to execute the above-described data processing method when running.

[0017] According to another aspect of the embodiments of this application, a computer program product or computer program is provided, which includes computer instructions stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the data processing method described above.

[0018] According to another aspect of the embodiments of this application, an electronic device is also provided, including a memory and a processor, wherein the memory stores a computer program and the processor is configured to execute the data processing method described above through the computer program.

[0019] In this embodiment, while the target client is running, a set of target functions is obtained. This set of target functions is the set of functions called by the target client through the target software development kit (SDK). A target linked list associated with the target SSD is generated based on the target function set. Each node in the target linked list corresponds one-to-one with a function in the target function set. In response to a function request message from the target client, the target function is captured using the target node, and the initial data parameters passed in the target function are processed into target data parameters of a preset format. The target linked list includes target nodes, each corresponding to a target function. The function request message is used to request the invocation of the target function. The preset format represents a unified data format pre-set for the SSD allowed by the target client. By capturing the functions called by the SSD and storing the data in a unified manner, and using a proxy server to cache and forward the business data of the SSD, a unified storage function is ensured for different SSDs, facilitating developer maintenance. This reduces the load on the business server for processing requests, resulting in smoother page operations and improved SDK data processing efficiency. This solves the technical problem of low data processing efficiency of SSDs in related technologies. Attached Figure Description

[0020] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0021] Figure 1 This is a schematic diagram of an application environment for an optional data processing method according to an embodiment of this application;

[0022] Figure 2 This is a flowchart illustrating an optional data processing method according to an embodiment of this application;

[0023] Figure 3 This is a schematic diagram of an optional data processing method according to an embodiment of this application;

[0024] Figure 4 This is a schematic diagram of another optional data processing method according to an embodiment of this application;

[0025] Figure 5 This is a schematic diagram of another optional data processing method according to an embodiment of this application;

[0026] Figure 6 This is a schematic diagram of another optional data processing method according to an embodiment of this application;

[0027] Figure 7 This is a schematic diagram of another optional data processing method according to an embodiment of this application;

[0028] Figure 8 This is a schematic diagram of the structure of an optional data processing apparatus according to an embodiment of this application;

[0029] Figure 9 This is a schematic diagram of the structure of an optional data processing product according to an embodiment of this application;

[0030] Figure 10 This is a schematic diagram of the structure of an optional electronic device according to an embodiment of this application. Detailed Implementation

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

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

[0033] First, some nouns or terms that appear in the description of the embodiments of this application shall be interpreted as follows:

[0034] SDK: Short for Software Development Kit, it is a collection of files including lib, dll, .h, documentation, examples, etc. In this solution, SDK refers to the software package that runs on the client side.

[0035] SwiftPackage: Package management for Swift projects. Xcode supports creating and publishing Swift packages (managing SDKs developed using the Swift language), as well as adding, removing, and managing package dependencies. Its support for Swift packages is built on top of the open-source Swift package manager project.

[0036] Proxy Server: A proxy server is a relay station for network information, acting as an intermediary between a personal network and an Internet service provider. In this solution, the proxy server is built into the middleware; data is visible to the client and is not controlled by a third party, thus ensuring security for the client.

[0037] The present application will be described below with reference to embodiments:

[0038] According to one aspect of the embodiments of this application, a data processing method is provided. Optionally, in this embodiment, the above-described data processing method can be applied to, for example... Figure 1 The hardware environment shown consists of server 101 and terminal device 103. For example... Figure 1 As shown, server 101 is connected to terminal 103 via a network and can be used to provide services to terminal devices or applications installed on terminal devices. The applications can be video applications, instant messaging applications, browser applications, educational applications, game applications, etc. Database 105 can be set up on the server or independently of the server to provide data storage services for server 101, such as a game data storage server. The network mentioned above can include, but is not limited to, wired networks and wireless networks. The wired network includes local area networks, metropolitan area networks, and wide area networks. The wireless network includes Bluetooth, WIFI, and other networks that enable wireless communication. Terminal device 103 can be a terminal configured with an application, and can include, but is not limited to, at least one of the following: mobile phones (such as Android phones, iOS phones, etc.), laptops, tablets, handheld computers, MID (Mobile Internet Devices), PADs, desktop computers, smart TVs, smart voice interaction devices, smart home appliances, vehicle terminals, aircraft, virtual reality (VR) terminals, augmented reality (AR) terminals, mixed reality (MR) terminals, and other computer devices. The server mentioned above can be a single server, a server cluster composed of multiple servers, or a cloud server.

[0039] It should be noted that the aforementioned servers can be independent physical servers, server clusters or distributed systems composed of multiple physical servers, or cloud servers providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms. Terminals can be smart speakers, smartwatches, etc., but are not limited to these. Terminals and servers can be directly or indirectly connected via wired or wireless communication methods; this application does not impose any restrictions on this.

[0040] Combination Figure 1 As shown, the above data processing method can be implemented in terminal device 103 through the following steps:

[0041] S1, with the target client in a running state, obtain the target function set on the terminal device 103, wherein the target function set is the set of functions called by the target client through the target software development kit;

[0042] S2, on the terminal device 103, a target linked list associated with the target software development kit is generated based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set;

[0043] S3, in response to the function request message from the target client, the target function is captured on the terminal device 103 using the target node, and the initial data parameters passed in the target function are processed into target data parameters in a preset format. The target linked list includes target nodes, and the target nodes correspond to the target functions. The function request message is used to request the call of the target function. The preset format represents a unified data format that is pre-set for the software development kit that the target client is allowed to use.

[0044] Optionally, in this embodiment, the above data processing method can also be implemented through a server, for example, Figure 1 It is implemented in server 101 shown; or it is implemented jointly by the terminal device and the server.

[0045] The above is merely an example, and this embodiment does not impose any specific limitations.

[0046] Alternatively, as an alternative implementation method, such as Figure 2 As shown, the data processing methods include:

[0047] S202, with the target client in a running state, obtain the target function set, where the target function set is the set of functions called by the target client through the target software development kit;

[0048] Optionally, in this embodiment, the target client may include, but is not limited to, clients that execute various services. A client, also known as a user terminal, refers to a program that provides local services to a client in relation to a server. Apart from some applications that run only locally, these are generally installed on ordinary client machines and need to cooperate with the server to run. With the development of the Internet, commonly used client machines include web browsers used for the World Wide Web, email clients for sending and receiving emails, and instant messaging client software. For these types of applications, corresponding servers and service programs are required on the network to provide the corresponding services, such as database services, email services, etc. Therefore, a specific communication connection needs to be established between the client and the server to ensure the normal operation of the application.

[0049] For example, the target client mentioned above may include, but is not limited to, instant messaging clients, payment clients, video clients, conferencing clients, etc.

[0050] Optionally, in this embodiment, the aforementioned running state may include, but is not limited to, the target client being in a running state, where running state refers to the state in which a program is running. That is, when a program is opened and made to run, that program is in a running state.

[0051] For example, the aforementioned runtime state may include, but is not limited to, when the Runtime API (Application Programming Interface) is invoked, which can be understood as the target client being in a runtime state. For instance, creating an object through Runtime can be understood as the client being in a runtime state.

[0052] Optionally, in this embodiment, the target function set may include, but is not limited to, the function set called by the target software development kit. Different software development kits may call different function sets, and different function sets may include the same functions. That is, different software development kits call different function sets respectively, but the same functions are allowed to exist in different function sets.

[0053] It should be noted that the functions included in the target function set corresponding to the aforementioned target software development kit can be preset by the system or periodically updated from the server.

[0054] Optionally, in this embodiment, the aforementioned target software development kit may include, but is not limited to, a collection of development tools used to create application software for specific software packages, software frameworks, hardware platforms, operating systems, etc. Software development tools, broadly speaking, refer to a collection of related documents, examples, and tools that assist in the development of a particular type of software.

[0055] It's important to note that a Software Development Kit (SDK) is a collection of development tools used by software engineers to create application software for specific software packages, frameworks, hardware platforms, operating systems, etc. It facilitates application creation through compilers, debuggers, software frameworks, and more. It can be as simple as some documentation providing an Application Programming Interface (API) for a programming language, but it may also include complex hardware capable of communicating with embedded systems. Typical tools include utilities for debugging and other purposes. An SDK also includes sample code, supporting technical annotations, or other supporting documentation to clarify any ambiguities in the basic reference materials.

[0056] It should be noted that when the client executes specific functions of the SDK (such as taking photos with a beauty camera, loading pages, and location navigation), it will obtain data by sending requests. According to the agreed protocol and data format with the server, the client will perform operations such as parsing, loading, and caching after receiving the server's response.

[0057] For example, Figure 3 This is a schematic diagram of an optional data processing method according to an embodiment of this application, such as... Figure 3 As shown, the target client is allowed to use SDK1, SDK2 and SDK3. The above three SDKs correspond to different SDK servers. Each SDK has a set of functions that are allowed to be called. When the target client calls SDK1 to execute a certain function, it obtains the function set corresponding to SDK1. At this time, SDK1 is the target software development kit mentioned above, and the function set corresponding to SDK1 is the target function set mentioned above.

[0058] S204, Generate a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set;

[0059] Optionally, in this embodiment, the target linked list may include, but is not limited to, a doubly linked list, also called a doubly linked list, which is a type of linked list where each data node has two pointers, pointing to the direct successor and the direct predecessor, respectively. Therefore, starting from any node in the doubly linked list, its predecessor and successor nodes can be accessed very easily.

[0060] It should be noted that each node in the target linked list corresponds to a function in the target function set. This node contains the function, and the elements in the target function set are the function names converted to C++. Besides the function address and parameters, each element also includes the caller and message receiver. For example, in a function that loads a local file, the data stored in the target function set includes the function name, function address, and parameters; the caller is a page, and the receiver is a tag on that page. Elements in the target function set can be updated from the server in a polling manner. The target linked list is created by traversing the target function set, and a head pointer without content is declared, pointing to the first element of the target function set. By modifying the address moved by the head pointer, elements in the target function set are extracted, generating function names with a specific prefix, which become nodes in the linked list. These nodes are used to replace functions in the target function set during runtime. For example, the function for reading a file is `loadLocalFile`, and the corresponding node in the linked list is `AB_loadLocalFile`. When the traversal of the target function set is complete, the nodes created in the doubly linked list represent the functions in the target function set.

[0061] Optionally, in this embodiment, the target linked list associated with the target software development kit can be understood as the target linked list corresponding to the target software development kit. When the target software development kit is called, the target linked list is generated to complete the capture of the function call of the target software development kit.

[0062] S206, in response to the function request message from the target client, capture the target function using the target node, and process the initial data parameters passed in the target function into target data parameters in a preset format. The target linked list includes target nodes, each corresponding to a target function. The function request message is used to request the invocation of the target function. The preset format represents a uniform data format pre-set for the software development kits allowed by the target client.

[0063] Optionally, in this embodiment, the aforementioned function request message may include, but is not limited to, the request message associated with the function that the target client needs to perform. In an exemplary embodiment, Figure 4 This is a schematic diagram of another optional data processing method according to an embodiment of this application, such as... Figure 4 As shown, when the target client needs to play a video, the process typically includes the following:

[0064] S1, reads the video file on the target client;

[0065] S2, pass the path to the target client;

[0066] S3 determines the video format on the target client;

[0067] S4, open the player on the target client;

[0068] S5 plays the video stream on the target client.

[0069] The process of reading the video file mentioned above will generate the aforementioned function request message to call the relevant function to read the locally stored video file. The data reading is completed in step S1. Similarly, when the data is written, a similar API function will be called. It should be noted that the above-mentioned input path and video format can be implemented by calling the WinExec function in the C++ coding environment. This function includes two parameters: the first specifies the path and the second specifies the display method. The above is just an example, and this embodiment does not make any specific limitations.

[0070] Optionally, in this embodiment, the target node may include, but is not limited to, the node corresponding to the target function in the target linked list. The target node includes the function name, function address, parameters, caller, and receiver of the target function. Therefore, by accessing the target node, the target function can be captured and the initial data parameters passed by the target function can be obtained.

[0071] Optionally, in this embodiment, the target function is the function determined according to the function request message. The target function is a function in the target function set. Since a target linked list is created, the target node can be accessed in the target linked list to capture the target function and obtain the initial data parameters passed in the target function.

[0072] Optionally, in this embodiment, the above-mentioned preset format can be flexibly set according to actual needs. For example, it can be set to binary format, hexadecimal format, etc. The above-mentioned preset format is a unified data format set by the software development kits allowed by the target client. That is, the data passed by the function calls of different software development kits are all processed into the above-mentioned preset format data parameters to achieve unified storage of different software development kits.

[0073] It should be noted that the data processing methods mentioned above can be applied to, but are not limited to, cloud technology. Cloud technology refers to a hosting technology that unifies hardware, software, and network resources within a wide area network (WAN) or local area network (LAN) to achieve data computation, storage, processing, and sharing. Cloud computing refers to the delivery and usage model of IT infrastructure, meaning obtaining required resources through a network in an on-demand and easily scalable manner. In a broader sense, cloud computing refers to the delivery and usage model of services, meaning obtaining required services through a network in an on-demand and easily scalable manner. These services can be IT and software-related, internet-related, or other services. Cloud computing is a product of the development and integration of traditional computer and network technologies such as grid computing, distributed computing, parallel computing, utility computing, network storage technologies, virtualization, and load balancing.

[0074] With the development of the internet, real-time data streams, and the diversification of connected devices, as well as the demands for search services, social networks, mobile commerce, and open collaboration, cloud computing has rapidly developed. Unlike previous parallel distributed computing, cloud computing will fundamentally revolutionize the entire internet model and enterprise management model.

[0075] Cloud storage is a new concept that extends and develops from the concept of cloud computing. A distributed cloud storage system (hereinafter referred to as a storage system) refers to a storage system that uses cluster applications, grid technology, and distributed storage file systems to bring together a large number of storage devices of various types (storage devices are also called storage nodes) in the network to work together through application software or application interfaces to provide data storage and business access functions to the outside world.

[0076] Currently, the storage method of a storage system is as follows: Logical volumes are created. During the creation of a logical volume, physical storage space is allocated to each logical volume. This physical storage space may consist of disks from one or more storage devices. Clients store data on a logical volume, which means storing the data on the file system. The file system divides the data into many parts, each part being an object. Each object contains not only the data but also additional information such as a data identifier (ID, ID entity). The file system writes each object to the physical storage space of the logical volume and records the storage location information of each object. Therefore, when a client requests access to data, the file system can allow the client to access the data based on the storage location information of each object. The process of allocating physical storage space to a logical volume is as follows: Based on the capacity estimate of the objects stored in the logical volume (this estimate often has a large margin relative to the actual capacity of the objects to be stored) and the grouping of Redundant Array of Independent Disks (RAID), the physical storage space is pre-divided into stripes. A logical volume can be understood as a stripe, thus allocating physical storage space to the logical volume.

[0077] A database, simply put, can be viewed as an electronic filing cabinet—a place to store electronic files, where users can perform operations such as adding, querying, updating, and deleting data. A "database" is a collection of data stored together in a certain way, capable of being shared by multiple users, with minimal redundancy, and independent of application programs.

[0078] In one exemplary embodiment, Figure 5 This is a schematic diagram of another optional data processing method according to an embodiment of this application, such as... Figure 5 As shown, the target client is allowed to use SDK1, SDK2, SDK3, SDK4, and SDK5. These five SDKs correspond to different SDK servers. Each SDK has a pre-set set of functions that can be called. When the target client calls SDK1 to execute a certain function, the plugin obtains the function set corresponding to SDK1. At this time, SDK1 is the target software development kit mentioned above, and the function set corresponding to SDK1 is the target function set mentioned above. After obtaining the target function set, a target linked list is created on the plugin. By accessing the target nodes in the target linked list, the initial data parameters are converted into target data parameters and stored uniformly in the target client according to the preset format.

[0079] This embodiment acquires a set of target functions while the target client is running. This set consists of functions called by the target client through the target software development kit (SDK). A target linked list associated with the SSD is generated based on the target function set, where each node in the linked list corresponds one-to-one with a function in the target function set. In response to a function request message from the target client, the target functions are captured using the target nodes, and the initial data parameters passed in the target functions are processed into target data parameters of a preset format. The target linked list includes target nodes, each corresponding to a target function. The function request message requests the invocation of the target function. The preset format represents a unified data format pre-set for the SSD allowed by the target client. By capturing the functions called by the SSD and storing the data in a unified manner, and using a proxy server to cache and forward the business data of the SSD, a unified storage function is ensured for different SSDs, facilitating developer maintenance. This reduces the load on the business server, resulting in smoother page operations and improved SDK data processing efficiency. Ultimately, this solves the technical problem of low data processing efficiency in related technologies.

[0080] As an optional approach, the above method further includes: pre-setting multiple sets of functions to be captured before the target client is running, wherein the multiple sets of functions include function sets corresponding to multiple software development kits allowed by the target client, one software development kit is mapped to one function set, and the multiple sets of functions include a target function set; generating a target linked list based on the target function set, including: traversing each function set in the multiple sets of functions and creating a set of linked lists, wherein one linked list in the set of linked lists has a one-to-one correspondence with one function set in the multiple sets of functions, one node in one linked list has a one-to-one correspondence with one function in one function set, and the set of linked lists includes the target linked list.

[0081] Optionally, in this embodiment, the aforementioned pre-setting of multiple function sets to be captured before the target client is in the running state can be understood as the aforementioned multiple function sets being set during the installation of the target client on the target terminal, and the aforementioned multiple function sets can be updated from the server in a polling manner, with different software development kits corresponding to different function sets.

[0082] Optionally, in this embodiment, the above-mentioned traversal of each function set in multiple function sets to create a linked list can be understood as traversing each function in each function set to create a linked list when the target client calls multiple software development kits.

[0083] For example, each function set is traversed, a doubly linked list is created, and a head pointer without content is declared, pointing to the first element of each function set. Elements in each function set are extracted by modifying the address the head pointer moves to, generating function names with specific prefixes, which become nodes in the linked list. These nodes are used to replace functions in the target function set during runtime. When the SDK generates a function call, the plugin matches the functions in each function set. At this point, the doubly linked list replaces the address of the function to be called, capturing the passed parameters, caller, and receiver.

[0084] As an optional approach, traverse each of the multiple function sets and create a set of linked lists, including: traversing the target function set and creating a target linked list as follows: create an initial linked list and set a target pointer, where the target pointer is set to point to the first function in the target function set; modify the movement address of the target pointer and extract the functions in the target function set sequentially; generate a node with a target identifier for each function in the target function set, and create a target linked list, where the target identifier is used to indicate that the target linked list is associated with the target software development kit.

[0085] Optionally, in this embodiment, the initial linked list may include, but is not limited to, a linked list that stores empty data. By setting pointers to functions in the target function set, nodes are generated for all functions in turn to finally obtain the target linked list. The target identifier may be set to be related to the target software development kit. For example, the target identifier may be set to the service provider identifier of the target software development kit.

[0086] Optionally, in this embodiment, the target pointer may include, but is not limited to, the head pointer corresponding to the pointer field of the doubly linked list. The head pointer may include, but is not limited to, the direct predecessor node of the current node, and the pointer may also include, but is not limited to, the direct successor node of the current node.

[0087] This embodiment uses a header pointer without content to point to the first function in the target function set. By modifying the address where the header pointer moves, the elements in the target function set are extracted sequentially. This allows the capture of the parameters passed to the target function, the caller, and the receiver. This reduces the load on the business server for processing requests, makes page operations smoother, and improves the efficiency of SDK data processing. In turn, it solves the technical problem of low data processing efficiency in related technologies.

[0088] As an optional approach, in response to a function request message from the target client, the target node is used to capture the target function, and the initial data parameters passed in the target function are processed into target data parameters of a preset format. This includes: in response to a function request message from the target client, if the function request message indicates a request to write target data parameters, controlling the target software development kit to call the target function, capturing the target function using the target node, and processing the initial data parameters into target data parameters; the above method further includes: in response to a function request message from the target client, if the function request message indicates a request to read target data parameters, controlling the target software development kit to call the target function, access the target node, and read the target data parameters, wherein the target function has been captured during the writing process.

[0089] Optionally, in this embodiment, it can be determined whether the target function has been captured based on the type of the function request message, and then subsequent operations can be performed according to whether the target function has been captured. Since data needs to be written or modified before it can be read, the data reading process will be directly completed by the linked list function in the plugin, without the need for re-capture.

[0090] In one exemplary embodiment, Figure 6 This is a schematic diagram of another optional data processing method according to an embodiment of this application, such as... Figure 6 As shown, it includes the following steps:

[0091] S1, It was detected that the SDK (corresponding to the aforementioned target software development kit) called the write data interface (which corresponds to the target function);

[0092] S2, determine whether the objective function has been captured. If the result of S2 is yes, proceed directly to step S7.

[0093] S3, if the result of S2 is negative, create set M (corresponding to the aforementioned set of objective functions);

[0094] S4, activate the plugin;

[0095] S5, iterates through collection M using the plugin;

[0096] S6, Generate the target linked list;

[0097] S7, replace the function in M ​​with a node in the linked list.

[0098] The above is merely an example, and this application does not impose any specific limitations.

[0099] As an optional approach, the above method further includes: performing initialization operations on the environment variables when the target function is called during the process of capturing the target function using the target node, and determining the target environment variables; determining the data type of the target data parameters based on the target environment variables; and creating a first thread based on the data type, wherein the first thread is used to process the initial data parameters into target data parameters.

[0100] Optionally, in this embodiment, the aforementioned environment variables are determined based on the data type of the target data parameters. The data type of the target data parameters may include, but is not limited to, files, model objects, key-value pairs, databases, etc. The aforementioned initialization operation can be understood as initializing the environment variables in memory in response to the aforementioned function request message, so as to determine the data type of the aforementioned target data parameters.

[0101] It should be noted that after the target function to be called is determined in the operating system, the target function will pass in relevant parameters to indicate the data type to be processed. At this time, the memory environment variables will be initialized to allow the target function to process the data parameters of that data type.

[0102] Optionally, in this embodiment, the first thread can be understood as a thread created in memory to process the initial data parameters into target data parameters, and the type of the thread is determined according to the data type.

[0103] As an optional approach, after creating the corresponding first thread based on the data type, the method further includes: loading the initial data parameters into the first thread and converting them into target data parameters; storing the target data parameters in the target terminal where the target client is located, wherein the target terminal is used to store data parameters corresponding to different software development kits that the target client is allowed to call.

[0104] Optionally, in this embodiment, loading the initial data parameters into the first thread and converting them into target data parameters can be understood as converting the initial data parameters into data parameters in a preset format in the first thread. After the conversion is completed, the target data parameters can be stored in the target terminal where the target client is located, so as to realize the storage of data parameters generated by different software development kits that are uniformly stored in a preset format on the target terminal.

[0105] As an optional approach, the initial data parameters are loaded into the first thread and transformed into target data parameters, including:

[0106] The initial data parameters are loaded into the first thread, and a mutex lock is added. The mutex lock is used to indicate that the initial data parameters are not allowed to be modified by the second thread during the process of converting them into target data parameters. The second thread is different from the first thread.

[0107] Remove the mutex lock after the initial data parameters have been converted into the target data parameters.

[0108] Optionally, in this embodiment, the second thread is the thread that needs to continue processing the target data parameters. However, during the process of the first thread converting the initial data parameters into target data parameters, the second thread is prohibited from modifying the target data parameters because a mutex lock is added. After the initial data parameters have been converted into target data parameters, the mutex lock is removed, and at this time, the second thread is allowed to modify the target data parameters.

[0109] In an exemplary embodiment, a mutex lock can be added to protect the data modification operation in the thread. For example, when other threads (corresponding to the second thread mentioned above) delete certain fields in the file, they will wait for the current conversion operation to be completed before deleting. The role of the mutex lock is to add a lock (corresponding to the aforementioned mutex lock) when the data conversion starts and release the lock after the conversion is completed.

[0110] As an optional approach, after loading the initial data parameters into the first thread and converting them into target data parameters, the above method further includes: when the function request message indicates a request to write the target data parameters, performing an encoding operation on the target data parameters to obtain the first data parameters; when the function request message indicates a request to read the target data parameters, performing a decoding operation on the first data parameters to obtain the target data parameters, wherein the decoding operation corresponds to the encoding operation.

[0111] Optionally, in this embodiment, the above encoding operation and decoding operation are corresponding and can be understood as the above decoding operation being used to decode the data encoded by the above encoding operation.

[0112] In an exemplary embodiment, after the initial data parameters are converted into target data parameters, the corresponding encoding algorithm is received from the plugin. Common encoding methods include shifting, complementing, and one's complement. For example, if the original binary data after conversion is 01110010, the key for performing the XOR (exclusive OR) operation is 00001111, and the encoded result is 01111101, then the encoded result is stored.

[0113] As an optional solution, the above method further includes: when the function request message is used to request the acquisition of business data, sending a target classification identifier to the proxy server, wherein the target classification identifier is used to identify the account type of the first account, the first account is the account that logs into the target client, the proxy server pre-classifies multiple accounts and assigns different classification identifiers to accounts of different account types among the multiple accounts, the multiple accounts include the first account; when the proxy server has cached the target business data, receiving the target business data returned by the proxy server, wherein the target business data is the business data requested by the second account that logs into the target client through the target software development kit, the second account has the same account type as the first account, the multiple accounts include the second account.

[0114] Optionally, in this embodiment, the aforementioned business data can be understood as business data requested by the target client from the corresponding server through a software development kit. This business data may include, but is not limited to, advertising data, video data, text data, etc. The aforementioned proxy server can be understood as a relay station for network information, acting as an intermediary between a personal network and an Internet service provider. In this solution, the proxy server is built into the middleware, and the data is visible to the client and will not be taken over by a third party, thus ensuring security for the client.

[0115] Optionally, in this embodiment, the target classification identifier is a classification identifier pre-assigned by the proxy server to the account of the login target client based on historical data.

[0116] In one exemplary embodiment, the SDK pre-classifies the corresponding request parameters when retrieving business data. For example, in an advertising SDK, a bank app categorizes accounts based on their purchasing power into categories such as Platinum, Diamond, and Bronze. Different ads are pushed to accounts in different categories, while the same ads are pushed to accounts in the same category. Therefore, the proxy server caches the response data. When it receives a request of the same type, it returns the cached data using the classification identifier passed in by the client, and simultaneously updates the data on the business server.

[0117] The following specific examples will further explain this application:

[0118] When traditional industries undergo internet transformation, lacking a robust underlying technological foundation, they often rely on mature third-party technologies for software implementation. For example, SDK 1, including H5 containers, gateways, mini-programs, and OCR recognition, provides basic capabilities for clients in industries like banking, securities, and insurance. However, these clients may not exclusively use SDK 1; they may employ other SDKs. This can lead to inconsistencies in data processing and storage methods on the client side, resulting in inconsistent overall client loading efficiency and higher maintenance costs.

[0119] The middleware generated based on SwiftPackage serves as a unified storage and middleware proxy server to handle related issues at the data layer of the client SDK.

[0120] Regardless of which server the SDK in the client is connected to, or how local data is read and written, the middleware will unify its input and output. There may be multiple SDK servers, representing different servers for different SDK requests.

[0121] 1. The SDK calls relevant API functions to implement its functionality, and the execution of these functions depends on the input data. The plugin captures data read and write operations at runtime, and the process is as follows:

[0122] S1 creates a set of functions M to be captured within the plugin. Elements in M ​​are the function names converted to C++. Besides the function address and parameters, each element also contains the caller and message receiver. For example, in a function that loads a local file, the data stored in M ​​would be the function name, function address, and parameters; the caller would be a specific page, and the receiver would be a specific tag on that page. Elements in M ​​are typically updated from the server using a polling method.

[0123] S2: After startup, the plugin traverses the collection M, creates a doubly linked list, and declares a head pointer (without content) pointing to the first element of M. By modifying the address moved by the head pointer, elements in M ​​are extracted, generating function names with specific prefixes, which become nodes in the linked list. These nodes are used to replace functions in M ​​during runtime. For example, the function for reading a file is `loadLocalFile`, and the corresponding node in the linked list is `TMF_loadLocalFile`. When traversal of M ends, the doubly linked list creates nodes where each node represents the replaced function.

[0124] S3, when the SDK generates a function call, the plugin matches the function in M. At this time, the doubly linked list replaces the address of the function to be called and captures the passed parameters, caller and receiver.

[0125] Since data can only be read after it has been written or modified, the data reading process is directly completed by the linked list function in the plugin.

[0126] Second, the captured data (including files, model objects, key-value pairs, and databases) is converted using a proprietary encoding algorithm. For example, the read model objects are subjected to unified archiving processing. In an exemplary embodiment, Figure 7 This is a schematic diagram of another optional data processing method according to an embodiment of this application, such as... Figure 7 As shown:

[0127] Each function initializes environment variables when it is called. These environment variables determine the data type (file, model object, key-value pair, database) and create the corresponding execution thread to load the data into memory and convert it into binary.

[0128] Mutex locks are used to protect data modification operations within threads. For example, if another thread wants to delete certain fields in a file, it will wait for the current conversion operation to complete before deleting. The purpose of the mutex lock is to add a lock when data conversion begins and release the lock after conversion ends. After the binary data conversion is complete, the corresponding encoding algorithm is received from the plugin. Common encoding methods include shift, complement, and inverse complement. For example, if the original binary data after conversion is 01110010, and the key for the XOR operation is 00001111, the encoded result is 01111101, which is then stored.

[0129] A corresponding algorithm is used for decoding when performing read operations. For example, if the encoded binary value is 01111101, the original binary data can be obtained by performing an XOR operation with the same key 00001111. Since the function for reading data has been captured, the function in the doubly linked list is matched with the corresponding function in M, and the decoded data is passed in.

[0130] Third, when retrieving business data, the SDK pre-categorizes the corresponding request parameters. For example, in the advertising SDK, the bank app categorizes accounts based on their purchasing power into categories such as Platinum, Diamond, and Bronze. Different ads are pushed to accounts in different categories, while the same ads are pushed to accounts in the same category. Therefore, the proxy server caches the response data. When it receives a request of the same type, it returns the cached data using the category identifier passed in by the client, and simultaneously updates the data on the business server.

[0131] This embodiment utilizes runtime capture of SDK data reading interfaces to effectively locate the resource functions called and loaded by the SDK. Through the mapping relationship between set M and the doubly linked list, data encoding and decoding behaviors can be inserted during data read / write calls, ensuring unified storage functionality across different SDKs. Developers of the Xingfang App can inject their own encoding / decoding algorithms and business logic (such as data updates, data protection, and periodic data cleanup) into the read / write behavior, facilitating maintenance. Adding mutex locks to thread operations during data modification ensures data security in a multi-threaded environment. The proxy server can cache data retrieved by categorized accounts, reducing the load on the business server and resulting in smoother client-side page operations.

[0132] It is understood that in the specific embodiments of this application, data such as user information are involved. When the above embodiments of this application are applied to specific products or technologies, user permission or consent is required, and the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0133] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0134] According to another aspect of the embodiments of this application, a data processing apparatus for implementing the above-described data processing method is also provided. For example... Figure 8 As shown, the device includes:

[0135] The acquisition module 802 is used to acquire a set of target functions when the target client is running, wherein the set of target functions is a set of functions called by the target client through the target software development kit;

[0136] The generation module 804 is used to generate a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set;

[0137] The processing module 806 is used to respond to the function request message of the target client, capture the target function using the target node, and process the initial data parameters passed in the target function into target data parameters of a preset format. The target linked list includes the target node, the target node corresponds to the target function, the function request message is used to request the call of the target function, and the preset format represents a unified data format pre-set for the software development kits allowed by the target client.

[0138] As an optional solution, the device is further configured to: pre-set multiple sets of functions to be captured before the target client is in the running state, wherein the multiple sets of functions include sets of functions corresponding to multiple software development kits allowed by the target client, one software development kit is mapped to one set of functions, and the multiple sets of functions include the target set of functions; the device is configured to generate a target linked list based on the target set of functions by: traversing each set of functions in the multiple sets of functions and creating a set of linked lists, wherein one linked list in the set of linked lists has a one-to-one correspondence with one set of functions in the multiple sets of functions, one node in one linked list has a one-to-one correspondence with one function in one set of functions, and the set of linked lists includes the target linked list.

[0139] As an optional approach, the device is used to traverse each of the plurality of function sets to create a linked list in the following manner: traversing the target function set to create the target linked list in the following manner: creating an initial linked list and setting a target pointer, wherein the target pointer is set to point to the first function in the target function set; modifying the movement address of the target pointer and sequentially extracting functions in the target function set; generating a node with a target identifier for each function in the target function set, and creating the target linked list, wherein the target identifier is used to indicate that the target linked list is associated with the target software development kit.

[0140] As an optional solution, the device is configured to respond to the function request message from the target client in the following manner: capture the target function using the target node, and process the initial data parameters passed in the target function into target data parameters of a preset format: responding to the function request message from the target client, when the function request message indicates a request to write the target data parameters, controlling the target software development kit to call the target function, capturing the target function using the target node, and processing the initial data parameters into the target data parameters; the device is further configured to: responding to the function request message from the target client, when the function request message indicates a request to read the target data parameters, controlling the target software development kit to call the target function, access the target node, and read the target data parameters, wherein the target function has been captured during the writing process.

[0141] As an optional solution, the apparatus is further configured to: perform an initialization operation on the environment variables when the target function is called during the process of capturing the target function using the target node, and determine the target environment variables; determine the data type of the target data parameters according to the target environment variables; and create a first thread according to the data type, wherein the first thread is used to process the initial data parameters into the target data parameters.

[0142] As an optional solution, the device is further configured to: after creating a corresponding first thread according to the data type, load the initial data parameters into the first thread and convert them into the target data parameters; store the target data parameters in the target terminal where the target client is located, wherein the target terminal is used to store data parameters corresponding to different software development kits that the target client is allowed to call.

[0143] As an optional solution, the device is used to load the initial data parameters into the first thread and convert them into the target data parameters in the following manner: loading the initial data parameters into the first thread and adding a mutex lock, wherein the mutex lock is used to indicate that the initial data parameters are prohibited from being modified by a second thread during the conversion into the target data parameters, the second thread being different from the first thread; and deleting the mutex lock after the initial data parameters have been converted into the target data parameters.

[0144] As an optional solution, the apparatus is further configured to: after loading the initial data parameters into the first thread and converting them into the target data parameters, when the function request message indicates a request to write the target data parameters, perform an encoding operation on the target data parameters to obtain a first data parameter; when the function request message indicates a request to read the target data parameters, perform a decoding operation on the first data parameters to obtain the target data parameters, wherein the decoding operation corresponds to the encoding operation.

[0145] As an optional solution, the apparatus is further configured to: when the function request message is used to request the acquisition of business data, send a target classification identifier to the proxy server, wherein the target classification identifier is used to identify the account type of the first account, the first account is the account that logs into the target client, the proxy server pre-classifies multiple accounts and assigns different classification identifiers to accounts of different account types among the multiple accounts, the multiple accounts including the first account; when the proxy server has cached the target business data, receive the target business data returned by the proxy server, wherein the target business data is business data requested by the second account that logs into the target client through the target software development kit, the second account has the same account type as the first account, the multiple accounts include the second account.

[0146] According to one aspect of this application, a computer program product is provided, comprising a computer program / instructions containing program code for performing the methods shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network via a communication section 909, and / or installed from a removable medium 911. When the computer program is executed by a central processing unit 901, it performs various functions provided in embodiments of this application.

[0147] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0148] Figure 9 A schematic block diagram of a computer system architecture for implementing an electronic device according to embodiments of the present application is shown.

[0149] It should be noted that, Figure 9 The computer system 900 of the electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0150] like Figure 9As shown, the computer system 900 includes a central processing unit (CPU) 901, which can perform various appropriate actions and processes based on programs stored in read-only memory (ROM) 902 or programs loaded from storage section 908 into random access memory (RAM). The RAM 903 also stores various programs and data required for system operation. The CPU 901, ROM 902, and RAM 903 are interconnected via a bus 904. An input / output interface 905 (I / O interface) is also connected to the bus 904.

[0151] The following components are connected to the input / output interface 905: an input section 906 including a keyboard, mouse, etc.; an output section 907 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 908 including a hard disk, etc.; and a communication section 909 including a network interface card such as a local area network card, modem, etc. The communication section 909 performs communication processing via a network such as the Internet. A drive 910 is also connected to the input / output interface 905 as needed. A removable medium 911, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on the drive 910 as needed so that computer programs read from it can be installed into the storage section 908 as needed.

[0152] Specifically, according to embodiments of this application, the processes described in the various method flowcharts can be implemented as computer software programs. For example, embodiments of 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 communication section 909, and / or installed from removable medium 911. When the computer program is executed by central processing unit 901, it performs various functions defined in the system of this application.

[0153] According to another aspect of the embodiments of this application, an electronic device for implementing the above-described data processing method is also provided. This electronic device may be... Figure 1 The terminal device or server shown. This embodiment uses this electronic device as an example for illustration. Figure 10As shown, the electronic device includes a memory 1002 and a processor 1004. The memory 1002 stores a computer program, and the processor 1004 is configured to execute the steps of any of the above method embodiments via the computer program.

[0154] Optionally, in this embodiment, the aforementioned electronic device may be located in at least one of a plurality of network devices in a computer network.

[0155] Optionally, in this embodiment, the processor can be configured to perform the following steps via a computer program:

[0156] S1, with the target client in a running state, obtain the target function set, where the target function set is the set of functions called by the target client through the target software development kit;

[0157] S2, Generate a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set;

[0158] S3, in response to the function request message from the target client, captures the target function using the target node, and processes the initial data parameters passed in the target function into target data parameters in a preset format. The target linked list includes target nodes, each corresponding to a target function. The function request message is used to request the call to the target function. The preset format represents a unified data format pre-set for the software development kits allowed by the target client.

[0159] Alternatively, as those skilled in the art will understand, Figure 10 The structure shown is for illustrative purposes only. Electronic devices can also be smartphones (such as Android phones, iOS phones, etc.), tablets, PDAs, mobile internet devices (MIDs), PADs, and other terminal devices. Figure 10 This does not limit the structure of the aforementioned electronic devices or electronic equipment. For example, electronic devices or electronic equipment may also include components that are more... Figure 10 The more or fewer components shown (such as network interfaces, etc.), or having the same Figure 10 The different configurations shown.

[0160] The memory 1002 can be used to store software programs and modules, such as the program instructions / modules corresponding to the data processing method and apparatus in this embodiment. The processor 1004 executes various functional applications and data processing by running the software programs and modules stored in the memory 1002, thereby implementing the aforementioned data processing method. The memory 1002 may include high-speed random access memory and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 1002 may further include memory remotely located relative to the processor 1004, and these remote memories can be connected to the terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof. Specifically, the memory 1002 may be used, but is not limited to, to store information such as data parameters. As an example, such as... Figure 10 As shown, the memory 1002 may include, but is not limited to, the acquisition module 802, the generation module 804, and the processing module 806 in the data processing device. Furthermore, it may include, but is not limited to, other module units in the data processing device, which will not be described further in this example.

[0161] Optionally, the transmission device 1006 described above is used to receive or send data via a network. Specific examples of the network described above may include wired networks and wireless networks. In one example, the transmission device 1006 includes a Network Interface Controller (NIC), which can be connected to other network devices and routers via a network cable to communicate with the Internet or a local area network. In another example, the transmission device 1006 is a Radio Frequency (RF) module, used for wireless communication with the Internet.

[0162] In addition, the aforementioned electronic device also includes: a display 1008 for displaying the target client; and a connection bus 1010 for connecting the various module components in the aforementioned electronic device.

[0163] In other embodiments, the aforementioned terminal device or server can be a node in a distributed system, wherein the distributed system can be a blockchain system, which is a distributed system formed by connecting multiple nodes through network communication. The nodes can form a peer-to-peer (P2P) network, and any form of computing device, such as a server, terminal, or other electronic device, can become a node in the blockchain system by joining this peer-to-peer network.

[0164] According to one aspect of this application, a computer-readable storage medium is provided, from which a processor of a computer device reads computer instructions, and the processor executes the computer instructions, causing the computer device to perform a data processing method provided in various alternative implementations of the above-described data processing aspect.

[0165] Optionally, in this embodiment, the computer-readable storage medium may be configured to store a computer program for performing the following steps:

[0166] S1, with the target client in a running state, obtain the target function set, where the target function set is the set of functions called by the target client through the target software development kit;

[0167] S2, Generate a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set;

[0168] S3, in response to the function request message from the target client, captures the target function using the target node, and processes the initial data parameters passed in the target function into target data parameters in a preset format. The target linked list includes target nodes, each corresponding to a target function. The function request message is used to request the call to the target function. The preset format represents a unified data format pre-set for the software development kits allowed by the target client.

[0169] Optionally, in this embodiment, those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be implemented by a program instructing the hardware related to the terminal device. The program can be stored in a computer-readable storage medium, which may include: flash drive, read-only memory (ROM), random access memory (RAM), disk or optical disk, etc.

[0170] The sequence numbers of the embodiments in this application are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0171] If the integrated units in the above embodiments are implemented as software functional units and sold or used as independent products, they can be stored in the aforementioned computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause one or more computer devices (which may be personal computers, servers, or network devices, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application.

[0172] In the above embodiments of this application, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0173] In the several embodiments provided in this application, it should be understood that the disclosed client can be implemented in other ways. The device embodiments described above are merely illustrative; for example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling or direct coupling or communication connection may be through some interfaces, indirect coupling or communication connection between units or modules, and may be electrical or other forms.

[0174] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0175] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0176] The above description is only a preferred embodiment of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A data processing method, characterized in that, include: When the target client is running, obtain the target function set, wherein the target function set is the set of functions called by the target client through the target software development kit; A target linked list associated with the target software development kit is generated based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set; In response to the function request message from the target client, the target function is captured using the target node, and the initial data parameters passed in the target function are processed into target data parameters in a preset format. The target linked list includes the target node, the target node corresponds to the target function, the function request message is used to request the invocation of the target function, and the preset format represents a uniform data format pre-set for the software development kits allowed by the target client.

2. The method according to claim 1, characterized in that, The method further includes: before the target client is in the running state, pre-setting multiple function sets to be captured, wherein the multiple function sets include function sets corresponding to multiple software development kits allowed to be used by the target client, one software development kit is mapped to one function set, and the multiple function sets include the target function set; The step of generating a target linked list based on the target function set includes: traversing each function set in the plurality of function sets and creating a set of linked lists, wherein one linked list in the set of linked lists has a one-to-one correspondence with one function set in the plurality of function sets, one node in one linked list has a one-to-one correspondence with one function in one function set, and the set of linked lists includes the target linked list.

3. The method according to claim 2, characterized in that, The process of traversing each of the multiple function sets and creating a linked list includes: The target linked list is created by traversing the set of target functions as follows: Create an initial linked list and set a target pointer, wherein the target pointer is set to point to the first function in the target function set; Modify the movement address of the target pointer, and extract the functions in the target function set in sequence; For each function in the set of target functions, generate a node with a target identifier, and create the target linked list, wherein the target identifier is used to indicate that the target linked list is associated with the target software development kit.

4. The method according to claim 1, characterized in that, The step of responding to the function request message from the target client by capturing the target function using the target node and processing the initial data parameters passed in the target function into target data parameters of a preset format includes: responding to the function request message from the target client, when the function request message indicates a request to write the target data parameters, controlling the target software development kit to call the target function, capturing the target function using the target node, and processing the initial data parameters into the target data parameters; The method further includes: in response to a function request message from the target client, if the function request message indicates a request to read the target data parameters, controlling the target software development kit to call the target function, access the target node, and read the target data parameters, wherein the target function has been captured during the writing process.

5. The method according to claim 1, characterized in that, The method further includes: During the process of capturing the target function using the target node, an initialization operation is performed on the environment variables when the target function is called to determine the target environment variables; The data type of the target data parameter is determined based on the target environment variable; A first thread is created based on the data type, wherein the first thread is used to process the initial data parameters into the target data parameters.

6. The method according to claim 5, characterized in that, After creating the corresponding first thread based on the data type, the method further includes: The initial data parameters are loaded into the first thread and converted into the target data parameters; The target data parameters are stored in the target terminal where the target client is located, wherein the target terminal is used to store data parameters corresponding to different software development kits that the target client is allowed to call.

7. The method according to claim 6, characterized in that, The step of loading the initial data parameters into the first thread and converting them into the target data parameters includes: The initial data parameters are loaded into the first thread, and a mutex lock is added. The mutex lock is used to indicate that the initial data parameters are prohibited from being modified by the second thread during the process of being transformed into the target data parameters. The second thread is different from the first thread. If the initial data parameters have been converted into the target data parameters, delete the mutex lock.

8. The method according to claim 6, characterized in that, After loading the initial data parameters into the first thread and converting them into the target data parameters, the method further includes: When the function request message indicates a request to write the target data parameter, an encoding operation is performed on the target data parameter to obtain the first data parameter; When the function request message indicates a request to read the target data parameter, a decoding operation is performed on the first data parameter to obtain the target data parameter, wherein the decoding operation corresponds to the encoding operation.

9. The method according to claim 1, characterized in that, The method further includes: When the function request message is used to request the acquisition of business data, a target classification identifier is sent to the proxy server. The target classification identifier is used to identify the account type of the first account, which is the account that logs into the target client. The proxy server pre-classifies multiple accounts and assigns different classification identifiers to accounts of different account types among the multiple accounts. The multiple accounts include the first account. If the proxy server has cached the target business data, the target business data returned by the proxy server is received. The target business data is business data requested and obtained by the second account logging into the target client through the target software development kit. The second account has the same account type as the first account, and the multiple accounts include the second account.

10. A data processing apparatus, characterized in that, include: The acquisition module is used to acquire a set of target functions when the target client is running, wherein the set of target functions is a set of functions called by the target client through the target software development kit; A generation module is used to generate a target linked list associated with the target software development kit based on the target function set, wherein the nodes in the target linked list correspond one-to-one with the functions in the target function set; The processing module is used to respond to the function request message of the target client, capture the target function using the target node, and process the initial data parameters passed in the target function into target data parameters of a preset format. The target linked list includes the target node, the target node corresponds to the target function, the function request message is used to request the invocation of the target function, and the preset format represents a uniform data format pre-set for the software development kits allowed by the target client.

11. The apparatus according to claim 10, characterized in that, The device is further configured to: pre-set multiple function sets to be captured before the target client is in the running state, wherein the multiple function sets include function sets corresponding to multiple software development kits allowed to be used by the target client, one software development kit is mapped to one function set, and the multiple function sets include the target function set; The device is used to generate a target linked list based on the target function set in the following manner: traversing each function set in the plurality of function sets and creating a set of linked lists, wherein one linked list in the set of linked lists has a one-to-one correspondence with one function set in the plurality of function sets, one node in one linked list has a one-to-one correspondence with one function in one function set, and the set of linked lists includes the target linked list.

12. The apparatus according to claim 11, characterized in that, The device is used to traverse each of the plurality of function sets in the following manner to create a linked list: The target linked list is created by traversing the set of target functions as follows: Create an initial linked list and set a target pointer, wherein the target pointer is set to point to the first function in the target function set; Modify the movement address of the target pointer, and extract the functions in the target function set in sequence; For each function in the set of target functions, generate a node with a target identifier, and create the target linked list, wherein the target identifier is used to indicate that the target linked list is associated with the target software development kit.

13. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes a stored program, wherein the program can be executed by a terminal device or computer at runtime as described in any one of claims 1 to 9.

14. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method described in any one of claims 1 to 9.

15. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to execute the method described in any one of claims 1 to 9 through the computer program.

Images