CN107291731B - Processing method and device of computing service - Google Patents

Processing method and device of computing service Download PDF

Info

Publication number
CN107291731B
CN107291731B CN201610196607.0A CN201610196607A CN107291731B CN 107291731 B CN107291731 B CN 107291731B CN 201610196607 A CN201610196607 A CN 201610196607A CN 107291731 B CN107291731 B CN 107291731B
Authority
CN
China
Prior art keywords
request
calculation
computation
computing
receiving
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
CN201610196607.0A
Other languages
Chinese (zh)
Other versions
CN107291731A (en
Inventor
苏晓明
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Alibaba Group Holding Ltd
Original Assignee
Alibaba Group Holding Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Alibaba Group Holding Ltd filed Critical Alibaba Group Holding Ltd
Priority to CN201610196607.0A priority Critical patent/CN107291731B/en
Publication of CN107291731A publication Critical patent/CN107291731A/en
Application granted granted Critical
Publication of CN107291731B publication Critical patent/CN107291731B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24Querying
    • G06F16/245Query processing
    • G06F16/2458Special types of queries, e.g. statistical queries, fuzzy queries or distributed queries
    • G06F16/2462Approximate or statistical queries

Abstract

The application discloses a processing method and device of computing services. Wherein, the method comprises the following steps: receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services; forwarding the computation request to an execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; and returning the secondary statistical result to the client. The method and the device solve the technical problem that the resource occupancy rate of the processing computing service to the client is too high in the prior art.

Description

Processing method and device of computing service
Technical Field
The present application relates to the field of computers, and in particular, to a method and an apparatus for processing a computing service.
Background
HBase is a distributed, column-oriented open-ended database. In the underlying storage structure of HBase, underlying data is divided into a plurality of data areas (regions), which are stored on a plurality of data area servers. If the user defines a service processing logic of an Endpoint (interface of a dynamic RPC plugin), the HBase may distribute the logic to a data area having a data storage function for parallel processing, and feed back a processing result obtained after the data area processing to the client, and the client may perform secondary processing such as aggregation operation on the processing result.
However, if the return value in the processing result obtained after the data area processing is large, a network bottleneck (some relevant factors affecting network transmission performance and stability, such as a network topology, a network cable, a network card, server configuration, and the like) of the client is easily caused, and then, if the client receives a large amount of data fed back from a plurality of data areas, the client greatly occupies computing resources, which causes a reduction in data processing capability of the client. In summary, the technical problem of high resource occupancy rate of the processing computing service to the client exists in the prior art.
In view of the above problems, no effective solution has been proposed.
Content of application
The embodiment of the application provides a method and a device for processing computing services, so as to at least solve the technical problem that the resource occupancy rate of the processing computing services to a client is too high in the prior art.
According to an aspect of an embodiment of the present application, a method for processing a computing service is provided, including: receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services; forwarding the computation request to the execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; and returning the secondary statistical result to the client.
According to another aspect of the embodiments of the present application, there is also provided a method for processing a computing service, including: receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range; according to the data calculation range, calculating to obtain a server list corresponding to the data calculation range; according to the server list, sending a calculation request to a corresponding server, wherein the calculation request is used for indicating the calculation service to be executed, the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, wherein the calculation result is generated by the execution main body executing the calculation service according to the calculation request; and receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate the secondary statistical result.
According to another aspect of the embodiments of the present application, there is also provided a processing apparatus for computing services, including: the system comprises a first receiving unit, a second receiving unit and a processing unit, wherein the first receiving unit is used for receiving a computing request, and the computing request is used for indicating computing services to be executed and execution subjects of the computing services; a forwarding unit, configured to forward the computation request to the execution subject; the second receiving unit is used for receiving a calculation result returned by the execution main body; the statistical unit is used for carrying out secondary statistics on the calculation result to generate a secondary statistical result; and the return unit is used for returning the secondary statistical result to the client.
Optionally, the statistical unit includes: an obtaining subunit, configured to obtain a user-defined quadratic computation logic; and the generating subunit is used for performing the secondary statistics on the calculation result according to the secondary calculation logic to generate the secondary statistical result.
Optionally, the forwarding unit includes: a determining subunit configured to determine the execution subject; and the forwarding subunit is used for starting an independent thread to forward the calculation request to the execution main body.
Optionally, the first receiving unit includes: the first receiving subunit is configured to receive a request instruction sent by the client invoking a real-time computing interface, where the request instruction includes the computing request.
According to another aspect of the embodiments of the present application, there is also provided a processing apparatus for computing services, including: the third receiving unit is used for receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range; the calculation unit is used for calculating to obtain a server list corresponding to the data calculation range according to the data calculation range; a sending unit, configured to send a computation request to a corresponding server according to the server list, where the computation request is used to indicate the computation service to be executed, the server forwards the computation request to an execution main body of the computation service, and receives a computation result returned by the execution main body, where the computation result is generated by the execution main body executing the computation service according to the computation request; and the fourth receiving unit is used for receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate the secondary statistical result.
Optionally, the sending unit includes: and the sending subunit is used for calling a real-time computing interface to send a request instruction to the server, wherein the request instruction comprises the computing request.
In the embodiment of the application, a computing request is received, wherein the computing request is used for indicating computing services to be executed and executing main bodies of the computing services; forwarding the computation request to an execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; by receiving the calculation request and forwarding the calculation request to the execution main body, the execution main body calculates the calculation request to obtain a calculation result, and the purpose of obtaining a secondary calculation result according to the calculation result and returning the secondary calculation result to the client is achieved, so that the technical effects of reducing the network load of the client, reducing the statistical pressure of the client and improving the processing efficiency and flexibility of the calculation request are achieved, and the technical problem that the resource occupancy rate of processing the calculation service to the client is overhigh in the prior art is solved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
fig. 1 is a block diagram of a hardware structure of a computer terminal of a processing method of a computing service according to an embodiment of the present application;
FIG. 2(a) is a flow chart illustrating an alternative method for processing computing services according to an embodiment of the present application;
FIG. 2(b) is a flow chart illustrating an alternative method for processing computing services according to an embodiment of the present application;
FIG. 3(a) is a flow chart illustrating an alternative method for processing computing services according to an embodiment of the present application;
FIG. 3(b) is a flowchart illustrating an alternative method for processing computing services according to an embodiment of the present application;
FIG. 4(a) is a flow chart illustrating an alternative method for processing computing services according to an embodiment of the present application;
FIG. 4(b) is a schematic diagram of an alternative processing method for computing services according to an embodiment of the present application;
FIG. 5(a) is a schematic structural diagram of an alternative processing apparatus for computing services according to an embodiment of the present application;
FIG. 5(b) is a schematic structural diagram of another alternative processing apparatus for computing services according to an embodiment of the present application;
FIG. 6 is a schematic structural diagram of a processing device for an alternative computing service according to an embodiment of the present application;
FIG. 7 is a schematic structural diagram of a processing device for an alternative computing service according to an embodiment of the present application;
FIG. 8 is a schematic structural diagram of a processing device for an alternative computing service according to an embodiment of the present application;
FIG. 9 is a schematic structural diagram of a processing device for an alternative computing service according to an embodiment of the present application;
FIG. 10 is a schematic structural diagram of a processing device for an alternative computing service according to an embodiment of the present application;
fig. 11 is a block diagram of a computer terminal according to an embodiment of the present application.
Detailed Description
In order to make the technical solutions better understood by those skilled in the art, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only partial embodiments of the present application, but not all embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
It should be noted that the terms "first," "second," and the like in the description and claims of this application and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the application described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
First, the technical terms related to the present embodiment are explained as follows:
and (3) secondary calculation logic: the calculation rules defined or set for the target object by the user, for example, the quadratic calculation logic is a loop processing for a certain target object.
Thread (thread): is the smallest unit of program execution flow. A standard thread consists of a thread ID, a current instruction Pointer (PC), a register set, and a stack. In addition, a thread is an entity in a process and is a basic unit independently scheduled and dispatched by a system, the thread does not own system resources and only owns resources which are indispensable in operation at a time, but the thread can share all the resources owned by the process with other threads belonging to the same process.
HBASE: is a distributed, column-oriented open source database.
API (Application Programming Interface): are predefined functions that are intended to provide applications and developers the ability to access a set of routines based on certain software or hardware without having to access source code or understand the details of the internal workings.
Example 1
There is also provided, in accordance with an embodiment of the present application, an embodiment of a method for processing computing services, to note that the steps illustrated in the flowchart of the figure may be performed in a computer system, such as a set of computer-executable instructions, and that, although a logical order is illustrated in the flowchart, in some cases the steps illustrated or described may be performed in an order different than here.
The method provided by the first embodiment of the present application may be executed in a mobile terminal, a computer terminal, or a similar computing device. Taking an example of the method running on a computer terminal, fig. 1 is a hardware structure block diagram of a computer terminal of a method for processing a computing service according to an embodiment of the present application. As shown in fig. 1, the computer terminal 10 may include one or more (only one shown) processors 102 (the processor 102 may include, but is not limited to, a processing device such as a microprocessor MCU or a programmable logic device FPGA), a memory 104 for storing data, and a transmission device 106 for communication functions. It will be understood by those skilled in the art that the structure shown in fig. 1 is only an illustration and is not intended to limit the structure of the electronic device. For example, the computer terminal 10 may also include more or fewer components than shown in FIG. 1, or have a different configuration than shown in FIG. 1.
The memory 104 may be configured to store software programs and modules of application software, such as program instructions/modules corresponding to the processing method of the computing service in the embodiment of the present application, and the processor 102 executes various functional applications and data processing by running the software programs and modules stored in the memory 104, that is, implements the vulnerability detection method of the application program. The memory 104 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 examples, the memory 104 may further include memory located remotely from the processor 102, which may be connected to the computer terminal 10 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
The transmission device 106 is used for receiving or transmitting data via a network. Specific examples of the network described above may include a wireless network provided by a communication provider of the computer terminal 10. In one example, the transmission device 106 includes a Network adapter (NIC) that can be connected to other Network devices through a base station to communicate with the internet. In one example, the transmission device 106 can be a Radio Frequency (RF) module, which is used to communicate with the internet in a wireless manner.
Under the above operating environment, the present application provides a processing method of computing services as shown in fig. 2 (a). Fig. 2(a) is a flowchart of a processing method of a computing service according to a first embodiment of the present application.
As shown in fig. 2(a), the processing method of the computing service may include the following implementation steps:
step S202, receiving a calculation request, wherein the calculation request is used for indicating a calculation service to be executed and an execution main body of the calculation service;
in the above step S202, the HTable client may receive the computation request.
Step S204, forwarding the calculation request to an execution main body;
in the above step S204 of the present application, since the data is stored in the execution body, the first calculation needs to be performed in the execution body. Furthermore, forwarding the computation request to the execution principal may be done by Protobuf. It should be noted that, a user needs to define an interface required for real-time computation and a data structure required to be transmitted based on Protobuf, including implementation of a two-stage real-time computation interface, that is, execution of a computation logic at a main body side and execution of a computation logic at a main body Server side.
Step S206, receiving a calculation result returned by the execution main body;
in step S206, the receiving of the calculation result returned by the execution principal can be completed by the execution principal server.
Step S208, carrying out secondary statistics on the calculation result to generate a secondary statistical result;
in the above step S208, the performing of the secondary statistics on the calculation result is not completed by the client, the execution subject does not need to feed back the calculation result to the client, but directly performs the secondary statistics by the execution subject server, and the execution subject server can perform the statistics in a concurrent manner, thereby reducing the network data transmission amount and optimizing the real-time calculation performance based on the Endpoint. In addition, when the main body server performs secondary statistics, a user can select or designate a specific statistical mode or statistical strategy, so that more flexible real-time calculation is realized.
And step S210, returning the secondary statistical result to the client.
In step S210, after receiving the secondary statistical result, the client may perform relevant operations such as deleting, replacing, and storing the secondary statistical result. The client may be an HTable client.
As can be seen from the above, in the solution provided in the first embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
Optionally, fig. 2(b) is a schematic flowchart of another optional processing method for computing a service according to an embodiment of the present application, and as shown in fig. 2(b), in step S208, performing secondary statistics on a computation result, and generating a secondary statistical result includes:
in step S201, a quadratic computation logic defined by a user is obtained.
In the above step S201 of the present application, the quadratic computation logic may be a computation rule defined or set by a user for a target object, for example, the quadratic computation logic is a loop processing for a certain target object.
And step S203, carrying out secondary statistics on the calculation result according to the secondary calculation logic to generate a secondary statistical result.
In the above step S203, performing secondary statistics on the calculation result may be performed by multiple execution main servers, so as to reduce the secondary statistical pressure of the client.
In an alternative solution provided by the foregoing embodiment of the present application, fig. 3(a) is a schematic flowchart of another optional processing method for computing services according to the embodiment of the present application, and as shown in fig. 3(a), step S204 of forwarding the computation request to the number execution main body includes:
step S302, determining an execution subject;
in step S302, the execution principal server may send the calculation request to the corresponding execution principal.
In step S304, the independent thread is started to forward the calculation request to the execution subject.
In the above step S304, the thread (thread) in the independent thread may also be referred to as a Lightweight Process (LWP), and the thread is the minimum unit of the program execution stream. A standard thread consists of a thread ID, a current instruction Pointer (PC), a register set, and a stack. The execution principal server may initiate an independent thread to forward the compute request to the corresponding execution principal.
Optionally, in step S202, the receiving a calculation request includes:
step S10 is to receive a request command sent by the client calling the real-time computing interface, where the request command includes a computing request.
In the above step S10, the client may perform real-time computation in a manner called by the HBASE CLIENT API, specifically, the client calls by a newly added interface public < T extensions Service, R > Map < byte [ ], R > coprocessorServiceRS (final Class < T > Service, byte [ ] startKey, byte [ ] endKey, final batch. The interface is an entry of a user call request, a specific calculation logic of a calculation service and corresponding secondary statistics needs to be provided when the user initiates the call request, a service parameter packages the primary and secondary calculation logics, the service is also an interface, and the user needs to define the calculation service and the corresponding secondary statistics in the service. The data calculation range is expressed by a start primary key Rowkey and an end primary key Rowkey, and the startKey and endKey parameters are the start and end primary keys and are used for filtering the data calculation range, and if a user does not want to filter any data, the two parameters are set to null values. The third parameter callable is a hook function implementation, and the inside of the program triggers the computing service and the corresponding secondary statistics by calling the call method of the callable parameter. In general, a program triggers computing service and corresponding secondary statistics through callable, primary computing and secondary computing logics are specifically defined in service parameters, and startKey and endKey parameters specify data computing and filtering ranges.
Optionally, the data structure of the calculation result is a coprocessor service data region value (rscoprocessorserviceregionvalues), and the data structure of the secondary statistical result is a coprocessor service response (RsCoprocessorServiceResponse).
Wherein, the calculation results of all execution bodies on the same execution body Server are collected and encapsulated into a coprocessor service data region value for the execution body Server to perform secondary calculation; the data structure returned to the client after the completion of the secondary computation performed on the execution subject Server is a coprocessor service response, which contains a computation result value.
Optionally, the client transfers a data structure RsCoprocessorServiceRequest when calling the real-time computing interface, where the data structure RsCoprocessorServiceRequest includes an execution subject Server list computed according to a data computing range specified by a user; meanwhile, the method also comprises a computing logic CoprocessorServiceCall realized by a user; the execution agent Server asynchronously forwards the request to the execution agent for computation, and the data structure returned to the execution agent Server after the computation on the execution agent is CoprocessorServiceResponse.
Optionally, fig. 3(b) is a schematic flowchart of another optional processing method for a computing service according to an embodiment of the present application, and as shown in fig. 3(b), the processing method for a computing service may include the following steps:
step S31, the user side defines a computation interface and a data interface, and specifically, the user side can implement a Protobuf two-stage computation and can also define a Protobuf data structure.
Step S32, the user terminal invokes the real-time computing interface and specifies the computing data range.
Step S33, the HTable client obtains the area corresponding to the area server according to the data range.
Step S34, the HTable client forwards and asynchronously calls the execution main body server terminal interface.
Step S35, the execution principal server forwards and asynchronously calls the corresponding execution principal interface.
In step S36, the execution subject returns the calculation result.
And step S37, executing the secondary computing interface of the execution main body server side.
In step S38a, the execution principal server returns the calculation result.
In step S38b, the HTable client runs the callback method.
Step S39, the HTable client returns the calculation result to the client.
Through the steps S31 to S39, the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the calculation request are achieved.
It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present application is not limited by the order of acts described, as some steps may occur in other orders or concurrently depending on the application. Further, those skilled in the art should also appreciate that the embodiments described in the specification are preferred embodiments and that the acts and modules referred to are not necessarily required in this application.
Through the above description of the embodiments, those skilled in the art can clearly understand that the method according to the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but the former is a better implementation mode in many cases. Based on such understanding, the technical solutions of the present application may be embodied in the form of a software product, which is stored in a storage medium (e.g., ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal device (e.g., a mobile phone, a computer, a server, or a network device) to execute the method according to the embodiments of the present application.
Example 2
There is also provided, in accordance with an embodiment of the present application, an embodiment of a method for processing computing services, to note that the steps illustrated in the flowchart of the figure may be performed in a computer system, such as a set of computer-executable instructions, and that, although a logical order is illustrated in the flowchart, in some cases the steps illustrated or described may be performed in an order different than here.
The method provided by the second embodiment of the present application can still be executed in a mobile terminal, a computer terminal, or a similar computing device. It should be noted here that the method embodiment provided in the second embodiment can still be run on the computer terminal shown in fig. 1.
Under the above operating environment, the present application provides a processing method of computing services as shown in fig. 4 (a). Fig. 4(a) is a flowchart illustrating a processing method of a computing service according to a second embodiment of the present application.
As shown in fig. 4(a), the processing method of the computing service may include the following implementation steps:
step S402, receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range.
In the above step S402, the call request may be called through a newly added interface public < T extensions Service, R > Map < byte [ ], R > coprocessorServiceRS (final Class < T > Service, byte [ ] startKey, byte [ ] endKey, final batch.
Optionally, the data query in the HBase database may be a single positioning query according to the home key Rowkey or a query according to the home key Rowkey range; the data calculation range in step S402 refers to the data calculation range in the table specified by the user, i.e., the data calculation range indicated by the Rowkey range of the table.
And step S404, calculating to obtain a server list corresponding to the data calculation range according to the data calculation range.
In step S404, the execution principal server may send the calculation request to the corresponding execution principal by starting the independent thread. Among them, the thread (thread) in the independent thread may also be called a Lightweight Process (LWP), and the thread is the minimum unit of the program execution flow. A standard thread consists of a thread ID, a current instruction Pointer (PC), a register set, and a stack. The execution principal server may initiate an independent thread to forward the compute request to the corresponding execution principal.
Step S406, sending a calculation request to a corresponding server according to the server list, where the calculation request is used to indicate a calculation service to be executed, and the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, where the calculation result is generated by the execution main body executing the calculation service according to the calculation request.
In the above step S406 of the present application, since the data is stored in the execution body, the first calculation needs to be performed in the execution body. Furthermore, forwarding the computation request to the execution principal may be done by Protobuf. It should be noted that, a user needs to define an interface required for real-time computation and a data structure required to be transmitted based on Protobuf, including implementation of a two-stage real-time computation interface, that is, execution of a computation logic at a main body side and execution of a computation logic at a main body Server side.
Step S408, receiving the secondary statistical result from the server, wherein the server performs secondary statistics on the calculation result to generate a secondary statistical result.
In step S408, the performing of the secondary statistics on the calculation result is not completed by the client, the execution subject does not need to feed back the calculation result to the client, but directly performs the secondary statistics by the execution subject server, and the execution subject server can perform the statistics in a concurrent manner, thereby reducing the network data transmission amount and optimizing the real-time calculation performance based on the Endpoint. In addition, when the main body server performs secondary statistics, a user can select or designate a specific statistical mode or statistical strategy, so that more flexible real-time calculation is realized.
As can be seen from the above, in the solution provided in the second embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
Optionally, before step S402, that is, before receiving the calculation call request, the method may further include:
step S20, responding to the operation of the user, and configuring the interface;
in the above step S20, the user operation may be a custom Map operation, or may also be a local Reduce operation defined to be executed on the execution principal Server.
In step S402, the receiving a calculation call request includes:
step S30, receiving a calculation calling request through an interface; the interface includes a start primary key and an end primary key for filtering the data computation scope, and a hook function for triggering computation traffic and quadratic statistics.
In the above step S30, the interface may be a User-defined User Service interface, and the interface may also be public < T extensions Service, R > Map < byte [ ], R > coprocessorServiceRS (final class < T > Service, byte [ ] sta rtKey, byte [ ] endKey, final batch.
Optionally, in step S406, sending the calculation request to the corresponding server includes:
and step S40, calling the real-time computing interface to send a request instruction to the server, wherein the request instruction comprises a computing request.
In the above step S40, the client may perform real-time computation in a manner called by the HBASE CLIENT API, specifically, the client calls by a newly added interface public < T extensions Service, R > Map < byte [ ], R > coprocessorServiceRS (final Class < T > Service, byte [ ] startKey, byte [ ] endKey, final batch.
Optionally, the data structure of the calculation result is a coprocessor service data area value, and the data structure of the secondary statistical result is a coprocessor service response.
Optionally, fig. 4(b) is a schematic diagram of a processing method of computing services according to the second embodiment of the present application, and as shown in fig. 4(b), the computation results of all execution entities on the same execution entity Server are collected and encapsulated into data structure coprocessor service data area values for the execution entity Server to perform secondary computation; the data structure returned to the client after the completion of the secondary computation performed on the execution subject Server is a coprocessor service response, which contains a computation result value.
Optionally, the client transfers a data structure RsCoprocessorServiceRequest when calling the real-time computing interface, where the data structure RsCoprocessorServiceRequest includes an execution subject Server list computed according to a data computing range specified by a user; meanwhile, the method also comprises a computing logic CoprocessorServiceCall realized by a user; the execution agent Server asynchronously forwards the request to the execution agent for computation, and the data structure returned to the execution agent Server after the computation on the execution agent is CoprocessorServiceResponse.
It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present application is not limited by the order of acts described, as some steps may occur in other orders or concurrently depending on the application. Further, those skilled in the art should also appreciate that the embodiments described in the specification are preferred embodiments and that the acts and modules referred to are not necessarily required in this application.
Through the above description of the embodiments, those skilled in the art can clearly understand that the method according to the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but the former is a better implementation mode in many cases. Based on such understanding, the technical solutions of the present application may be embodied in the form of a software product, which is stored in a storage medium (e.g., ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal device (e.g., a mobile phone, a computer, a server, or a network device) to execute the method according to the embodiments of the present application.
Example 3
According to an embodiment of the present application, there is further provided a processing apparatus for a computing service, which is used for implementing the processing method for the computing service, and as shown in fig. 5(a), the apparatus may include: first receiving section 501, forwarding section 503, second receiving section 505, counting section 507, and returning section 509.
The first receiving unit 501 is configured to receive a computation request, where the computation request is used to indicate a computation service to be executed; a forwarding unit 503, configured to forward the calculation request to the execution subject; a second receiving unit 505, configured to receive a calculation result returned by the execution subject; a statistic unit 507, configured to perform secondary statistics on the calculation result to generate a secondary statistic result; a returning unit 509, configured to return the secondary statistical result to the client.
It should be noted here that the first receiving unit 501, the forwarding unit 503, the second receiving unit 505, the statistical unit 507, and the returning unit 509 correspond to steps S202 to S210 in the first embodiment, and five units are the same as the corresponding steps in the implementation example and application scenario, but are not limited to the content disclosed in the first embodiment. It should be noted that the above units as a part of the apparatus may operate in the computer terminal 10 provided in the first embodiment.
As can be seen from the above, in the scheme provided in the third embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
Alternatively, as shown in fig. 5(b), the statistic unit 507 may include: an acquisition subunit 502 and a generation subunit 504.
The acquiring subunit 502 is configured to acquire a user-defined quadratic computation logic; and the generating subunit 504 is configured to perform secondary statistics on the calculation result according to the secondary calculation logic, and generate a secondary statistical result.
It should be noted here that the acquiring subunit 502 and the generating subunit 504 correspond to steps S201 to S203 in the first embodiment, and the two subunits are the same as the corresponding steps in the implementation example and application scenario, but are not limited to the disclosure in the first embodiment. It should be noted that the foregoing sub-units as a part of the apparatus may be operated in the computer terminal 10 provided in the first embodiment.
Optionally, as shown in fig. 6, the forwarding unit 503 may include: a determining subunit 601 and a forwarding subunit 603.
Wherein, the determining subunit 601 is configured to determine an execution subject; and a forwarding subunit 603, configured to start an independent thread to forward the computation request to the execution subject.
It should be noted here that the determining subunit 601 and the forwarding subunit 603 correspond to steps S302 to S304 in the first embodiment, and the two subunits are the same as the corresponding steps in the implementation example and application scenario, but are not limited to the disclosure in the first embodiment. It should be noted that the foregoing sub-units as a part of the apparatus may be operated in the computer terminal 10 provided in the first embodiment.
Alternatively, as shown in fig. 7, the first receiving unit 501 may include: a first receiving subunit 701.
The first receiving subunit 701 is configured to receive a request instruction sent by a client calling a real-time computing interface, where the request instruction includes a computing request.
It should be noted that the first receiving subunit 701 corresponds to the step S10 in the first embodiment, and this subunit is the same as the example and application scenario realized by the corresponding step, but is not limited to the disclosure in the first embodiment. It should be noted that the foregoing sub-units as a part of the apparatus may be operated in the computer terminal 10 provided in the first embodiment.
Optionally, the data structure of the calculation result is a coprocessor service data area value, and the data structure of the secondary statistical result is a coprocessor service response.
Example 4
According to an embodiment of the present application, there is further provided a processing apparatus for a computing service, where the processing apparatus is configured to implement the processing method for a computing service, and as shown in fig. 8, the apparatus may include: a third receiving unit 801, a calculating unit 803, a transmitting unit 805, a fourth receiving unit 807.
The third receiving unit 801 is configured to receive a calculation invocation request, where the calculation invocation request includes a data calculation range; the calculating unit 803 is configured to calculate, according to the data calculation range, a server list corresponding to the data calculation range; a sending unit 805, configured to send a computation request to a corresponding server according to a server list, where the computation request is used to indicate a computation service to be executed, and the server forwards the computation request to an execution main body of the computation service, and receives a computation result returned by the execution main body, where the computation result is generated when the execution main body executes the computation service according to the computation request; a fourth receiving unit 807, configured to receive the secondary statistical result from the server, wherein the server performs secondary statistics on the calculation result to generate a secondary statistical result.
It should be noted here that the third receiving unit 801, the calculating unit 803, the sending unit 805, and the fourth receiving unit 807 correspond to steps S402 to S408 in the second embodiment, and the four units are the same as the corresponding steps in the implementation example and application scenario, but are not limited to the disclosure in the second embodiment. It should be noted that the above units as a part of the apparatus may operate in the computer terminal 10 provided in the first embodiment.
As can be seen from the above, in the solution provided in the fourth embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
Alternatively, as shown in fig. 9, the apparatus may include: a processing unit 901; the third receiving unit 801 may include: a second receiving subunit 903.
The processing unit 901 is configured to perform interface configuration in response to an operation of a user; a second receiving subunit 903, configured to receive a computation invocation request through an interface; the interface includes a start primary key and an end primary key for filtering the data computation scope, and a hook function for triggering computation traffic and quadratic statistics.
It should be noted that the processing unit 901 corresponds to step S20 in the second embodiment, the second receiving subunit 903 corresponds to step S30 in the second embodiment, and the units or subunits are the same as those of the corresponding steps in the implementation example and application scenario, but are not limited to the disclosure in the second embodiment. It should be noted that the above units or sub-units as a part of the apparatus may be operated in the computer terminal 10 provided in the first embodiment.
Alternatively, as shown in fig. 10, the sending unit 805 may include: the transmitting subunit 1001.
The sending subunit 1001 is configured to invoke a real-time computing interface to send a request instruction to the server, where the request instruction includes a computing request.
It should be noted here that the sending subunit 1001 corresponds to step S40 in the second embodiment, and the subunit or the subunit is the same as the example and the application scenario realized by the corresponding step, but is not limited to the disclosure in the second embodiment. It should be noted that the foregoing sub-units as a part of the apparatus may be operated in the computer terminal 10 provided in the first embodiment.
Optionally, the data structure of the calculation result is a coprocessor service data area value, and the data structure of the secondary statistical result is a coprocessor service response.
Example 5
The embodiment of the application can provide a computer terminal, and the computer terminal can be any one computer terminal device in a computer terminal group. Optionally, in this embodiment, the computer terminal may also be replaced with a terminal device such as a mobile terminal.
Optionally, in this embodiment, the computer terminal may be located in at least one network device of a plurality of network devices of a computer network.
In this embodiment, the computer terminal may execute the program code of the following steps in the vulnerability detection method of the application program: receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services; forwarding the computation request to an execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; and returning the secondary statistical result to the client.
As can be seen from the above, in the scheme provided in the fifth embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
Optionally, fig. 11 is a block diagram of a computer terminal according to an embodiment of the present application. As shown in fig. 11, the computer terminal a may include: one or more processors 1101 (only one of which is shown), a memory 1103, and a transmitting device 1105.
The memory 1103 may be configured to store software programs and modules, such as program instructions/modules corresponding to the vulnerability detection method and apparatus in the embodiment of the present application, and the processor 1101 executes various functional applications and data processing by running the software programs and modules stored in the memory 1103, that is, implements the vulnerability detection method. The memory 1103 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 examples, the memory 1103 can further include memory located remotely from the processor, which can be connected to terminal a through a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
The transmission device 1105 is used for receiving or transmitting data via a network. Examples of the network may include a wired network and a wireless network. In one example, the transmission device 1105 includes a Network adapter (NIC) that can be connected to a router via a Network cable and other Network devices to communicate with the internet or a local area Network. In one example, the transmitting device 1105 is a Radio Frequency (RF) module, which is used to communicate with the internet in a wireless manner.
Specifically, the memory 1103 is used for storing preset action conditions, information of preset authorized users, and applications.
The processor 1101 may call the information and application stored in the memory 1103 through the transmission device 1105 to execute the following steps: receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services; forwarding the computation request to an execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; and returning the secondary statistical result to the client.
Optionally, the processor 1101 may further execute the program code of the following steps: acquiring a secondary calculation logic defined by a user; and carrying out secondary statistics on the calculation result according to the secondary calculation logic to generate a secondary statistical result.
Optionally, the processor 1101 may further execute the program code of the following steps: determining an execution subject; an independent thread is initiated to forward the compute request to the execution principal.
Optionally, the processor 1101 may further execute the program code of the following steps: and receiving a request instruction sent by a client calling the real-time computing interface, wherein the request instruction comprises a computing request.
It can be understood by those skilled in the art that the structure shown in fig. 11 is only an illustration, and the computer terminal may also be a terminal device such as a smart phone (e.g., an Android phone, an iOS phone, etc.), a tablet computer, a palmtop computer, a Mobile Internet Device (MID), a PAD, and the like. Fig. 11 is a diagram illustrating a structure of the electronic device. For example, the computer terminal a may also include more or fewer components (e.g., network interfaces, display devices, etc.) than shown in fig. 11, or have a different configuration than shown in fig. 11.
Those skilled in the art will appreciate that all or part of the steps in the methods of the above embodiments may be implemented by a program instructing hardware associated with the terminal device, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash disks, Read-Only memories (ROMs), Random Access Memories (RAMs), magnetic or optical disks, and the like.
Example 6
The embodiment of the application can also provide a computer terminal, and the computer terminal can be any computer terminal device in a computer terminal group. Optionally, in this embodiment, the computer terminal may also be replaced with a terminal device such as a mobile terminal.
Optionally, in this embodiment, the computer terminal may be located in at least one network device of a plurality of network devices of a computer network.
In this embodiment, the computer terminal may execute the program code of the following steps in the vulnerability detection method of the application program: receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range; according to the data calculation range, calculating to obtain a server list corresponding to the data calculation range; sending a calculation request to a corresponding server according to a server list, wherein the calculation request is used for indicating a calculation service to be executed, the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, and the calculation result is generated by the execution main body according to the calculation request to execute the calculation service; and receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate a secondary statistical result.
As can be seen from the above, in the scheme provided in the sixth embodiment of the present application, by receiving the computation request and forwarding the computation request to the execution main body, so that the execution main body obtains the computation result after computing the computation request, the purpose of obtaining the secondary statistical result according to the computation result and returning the secondary statistical result to the client is achieved, thereby achieving the technical effects of reducing the network load of the client, reducing the statistical pressure of the client, and improving the processing efficiency and flexibility of the computation request, and further solving the technical problem in the prior art that the resource occupancy rate of processing the computation service to the client is too high.
The method embodiment provided in the sixth embodiment of the present application can still be executed on the computer terminal shown in fig. 11, and the structure, the components, and the functions of each component of the computer terminal can refer to the description of the computer terminal in the fifth embodiment, which is not described herein again.
The processor 1101 may call the information and application stored in the memory 1103 through the transmission device 1105 to execute the following steps: receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range; according to the data calculation range, calculating to obtain a server list corresponding to the data calculation range; sending a calculation request to a corresponding server according to a server list, wherein the calculation request is used for indicating a calculation service to be executed, the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, and the calculation result is generated by the execution main body according to the calculation request to execute the calculation service; and receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate a secondary statistical result.
Optionally, the processor 1101 may further execute the program code of the following steps: responding to the operation of a user, and performing interface configuration; wherein receiving the computation invocation request includes: receiving a calculation calling request through an interface; the interface includes a start primary key and an end primary key for filtering the data computation scope, and a hook function for triggering computation traffic and quadratic statistics.
Optionally, the processor 1101 may further execute the program code of the following steps: and calling a real-time computing interface to send a request instruction to the server, wherein the request instruction comprises a computing request.
It can be understood by those skilled in the art that the structure shown in fig. 11 is only an illustration, and the computer terminal may also be a terminal device such as a smart phone (e.g., an Android phone, an iOS phone, etc.), a tablet computer, a palmtop computer, a Mobile Internet Device (MID), a PAD, and the like. Fig. 11 is a diagram illustrating a structure of the electronic device. For example, the computer terminal a may also include more or fewer components (e.g., network interfaces, display devices, etc.) than shown in fig. 11, or have a different configuration than shown in fig. 11.
Those skilled in the art will appreciate that all or part of the steps in the methods of the above embodiments may be implemented by a program instructing hardware associated with the terminal device, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash disks, Read-Only memories (ROMs), Random Access Memories (RAMs), magnetic or optical disks, and the like.
Example 7
Embodiments of the present application also provide a storage medium. Optionally, in this embodiment, the storage medium may be configured to store a program code executed by the processing method of the computing service provided in the first embodiment.
Optionally, in this embodiment, the storage medium may be located in any one of computer terminals in a computer terminal group in a computer network, or in any one of mobile terminals in a mobile terminal group.
Optionally, in this embodiment, the storage medium is configured to store program code for performing the following steps: receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services; forwarding the computation request to an execution principal; receiving a calculation result returned by the execution main body; performing secondary statistics on the calculation result to generate a secondary statistical result; and returning the secondary statistical result to the client.
It should be noted here that any one of the computer terminal groups may establish a communication relationship with the web server and the scanner, and the scanner may scan the value commands of the web application executed by the php on the computer terminal.
Example 8
Embodiments of the present application also provide a storage medium. Optionally, in this embodiment, the storage medium may be configured to store a program code executed by the vulnerability detection method provided in the first embodiment.
Optionally, in this embodiment, the storage medium may be located in any one of computer terminals in a computer terminal group in a computer network, or in any one of mobile terminals in a mobile terminal group.
Optionally, in this embodiment, the storage medium is configured to store program code for performing the following steps: receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range; according to the data calculation range, calculating to obtain a server list corresponding to the data calculation range; sending a calculation request to a corresponding server according to a server list, wherein the calculation request is used for indicating a calculation service to be executed, the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, and the calculation result is generated by the execution main body according to the calculation request to execute the calculation service; and receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate a secondary statistical result.
It should be noted here that any one of the computer terminal groups may establish a communication relationship with the web server and the scanner, and the scanner may scan the value commands of the web application executed by the php on the computer terminal.
The above-mentioned serial numbers of the embodiments of the present application are merely for description and do not represent the merits of the embodiments.
In the above embodiments of the present application, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.
In the embodiments provided in the present application, it should be understood that the disclosed technology can be implemented in other ways. The above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one type of division of logical functions, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, units or modules, and may be in an electrical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be substantially implemented or contributed to by the prior art, or all or part of the technical solution may be embodied in a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic or optical disk, and other various media capable of storing program codes.
The foregoing is only a preferred embodiment of the present application and it should be noted that those skilled in the art can make several improvements and modifications without departing from the principle of the present application, and these improvements and modifications should also be considered as the protection scope of the present application.

Claims (14)

1. A method for processing computing services, comprising:
receiving a computing request, wherein the computing request is used for indicating computing services to be executed and execution subjects of the computing services;
forwarding the computation request to the execution principal;
receiving a calculation result returned by the execution main body;
performing secondary statistics on the calculation result to generate a secondary statistical result;
returning the secondary statistical result to the client;
performing secondary statistics on the calculation result, wherein generating a secondary statistical result comprises: and performing secondary statistics by executing the main server to generate a secondary statistical result.
2. The method of claim 1, wherein performing secondary statistics on the calculation results, and generating secondary statistics comprises:
acquiring a secondary calculation logic defined by a user;
and performing the secondary statistics on the calculation result according to the secondary calculation logic to generate the secondary statistical result.
3. The method of claim 1, wherein forwarding the computation request to the execution agent comprises:
determining the execution subject;
and starting an independent thread to forward the calculation request to the execution body.
4. The method of claim 1, wherein receiving the computation request comprises:
and receiving a request instruction sent by the client calling a real-time computing interface, wherein the request instruction comprises the computing request.
5. A method for processing computing services, comprising:
receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range;
according to the data calculation range, calculating to obtain a server list corresponding to the data calculation range;
according to the server list, sending a calculation request to a corresponding server, wherein the calculation request is used for indicating the calculation service to be executed, the server forwards the calculation request to an execution main body of the calculation service, and receives a calculation result returned by the execution main body, wherein the calculation result is generated by the execution main body executing the calculation service according to the calculation request;
and receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate the secondary statistical result.
6. The method of claim 5, wherein prior to said receiving a compute call request, the method further comprises:
responding to the operation of a user, and performing interface configuration;
wherein the receiving a computation invocation request comprises:
receiving the computation invocation request through the interface;
the interface includes a start primary key and an end primary key for filtering the data computation range, and a hook function for triggering the computation traffic and the quadratic statistic.
7. The method of claim 5, wherein sending the computation request to the corresponding server comprises:
and calling a real-time computing interface to send a request instruction to the server, wherein the request instruction comprises the computing request.
8. An apparatus for processing computing traffic, comprising:
the system comprises a first receiving unit, a second receiving unit and a processing unit, wherein the first receiving unit is used for receiving a computing request, and the computing request is used for indicating computing services to be executed and execution subjects of the computing services;
a forwarding unit, configured to forward the computation request to the execution subject;
the second receiving unit is used for receiving a calculation result returned by the execution main body;
the statistical unit is used for carrying out secondary statistics on the calculation result to generate a secondary statistical result;
the return unit is used for returning the secondary statistical result to the client;
performing secondary statistics on the calculation result, wherein generating a secondary statistical result comprises: and performing secondary statistics by executing the main server to generate a secondary statistical result.
9. The apparatus of claim 8, wherein the statistical unit comprises:
an obtaining subunit, configured to obtain a user-defined quadratic computation logic;
and the generating subunit is used for performing the secondary statistics on the calculation result according to the secondary calculation logic to generate the secondary statistical result.
10. The apparatus of claim 8, wherein the forwarding unit comprises:
a determining subunit configured to determine the execution subject;
and the forwarding subunit is used for starting an independent thread to forward the calculation request to the execution main body.
11. The apparatus of claim 8, wherein the first receiving unit comprises:
the first receiving subunit is configured to receive a request instruction sent by the client invoking a real-time computing interface, where the request instruction includes the computing request.
12. An apparatus for processing computing traffic, comprising:
the third receiving unit is used for receiving a calculation calling request, wherein the calculation calling request comprises a data calculation range;
the calculation unit is used for calculating to obtain a server list corresponding to the data calculation range according to the data calculation range;
a sending unit, configured to send a computation request to a corresponding server according to the server list, where the computation request is used to indicate the computation service to be executed, the server forwards the computation request to an execution main body of the computation service, and receives a computation result returned by the execution main body, where the computation result is generated by the execution main body executing the computation service according to the computation request;
and the fourth receiving unit is used for receiving a secondary statistical result from the server, wherein the server carries out secondary statistics on the calculation result to generate the secondary statistical result.
13. The apparatus of claim 12, further comprising:
the processing unit is used for responding to the operation of a user and carrying out interface configuration;
wherein the third receiving unit includes:
the second receiving subunit is used for receiving the calculation calling request through the interface;
the interface includes a start primary key and an end primary key for filtering the data computation range, and a hook function for triggering the computation traffic and the quadratic statistic.
14. The apparatus of claim 12, wherein the sending unit comprises:
and the sending subunit is used for calling a real-time computing interface to send a request instruction to the server, wherein the request instruction comprises the computing request.
CN201610196607.0A 2016-03-31 2016-03-31 Processing method and device of computing service Active CN107291731B (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN201610196607.0A CN107291731B (en) 2016-03-31 2016-03-31 Processing method and device of computing service

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN201610196607.0A CN107291731B (en) 2016-03-31 2016-03-31 Processing method and device of computing service

Publications (2)

Publication Number Publication Date
CN107291731A CN107291731A (en) 2017-10-24
CN107291731B true CN107291731B (en) 2020-11-24

Family

ID=60087225

Family Applications (1)

Application Number Title Priority Date Filing Date
CN201610196607.0A Active CN107291731B (en) 2016-03-31 2016-03-31 Processing method and device of computing service

Country Status (1)

Country Link
CN (1) CN107291731B (en)

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101196831A (en) * 2007-12-29 2008-06-11 北京方正国际软件系统有限公司 Method, system and device for distributed multi-service logic asynchronous processing
WO2012169021A1 (en) * 2011-06-08 2012-12-13 株式会社日立製作所 Control method, control system, and program
CN103139287A (en) * 2012-12-11 2013-06-05 厦门雅迅网络股份有限公司 Map aggregation vehicle refreshing method based on distributed calculating
CN104243436A (en) * 2013-06-21 2014-12-24 中兴通讯股份有限公司 Service processing method, device and system
CN104580127A (en) * 2013-10-29 2015-04-29 腾讯科技(北京)有限公司 Business processing method, server and client side

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8127038B2 (en) * 2008-03-11 2012-02-28 International Business Machines Corporation Embedded distributed computing solutions

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101196831A (en) * 2007-12-29 2008-06-11 北京方正国际软件系统有限公司 Method, system and device for distributed multi-service logic asynchronous processing
WO2012169021A1 (en) * 2011-06-08 2012-12-13 株式会社日立製作所 Control method, control system, and program
CN103139287A (en) * 2012-12-11 2013-06-05 厦门雅迅网络股份有限公司 Map aggregation vehicle refreshing method based on distributed calculating
CN104243436A (en) * 2013-06-21 2014-12-24 中兴通讯股份有限公司 Service processing method, device and system
CN104580127A (en) * 2013-10-29 2015-04-29 腾讯科技(北京)有限公司 Business processing method, server and client side

Also Published As

Publication number Publication date
CN107291731A (en) 2017-10-24

Similar Documents

Publication Publication Date Title
Zhang et al. Toward a unified elastic computing platform for smartphones with cloud support
CN103905447A (en) Service link selection control method and device
CN103036853B (en) Business datum sending method and device, method for processing business and device
CN103873692A (en) Method, device and system for resource sharing
CN109831746B (en) Method and device for data transmission based on Bluetooth broadcast and Bluetooth equipment
CN105511946A (en) Intelligent home appliance equipment active degree statistic method and device and internet gateway
CN108062367B (en) Data list uploading method and terminal thereof
CN107291731B (en) Processing method and device of computing service
CN109005301A (en) Centre management-control method and centre control device
Lim et al. An application of a multi-generation diffusion model to forecast 5g mobile telecommunication service subscribers in south korea
CN104378682A (en) Key counting method based on android system and smart television based on android system
US10750356B2 (en) Configuration management method, apparatus, and system for terminal in internet of things
CN107872533B (en) Information-pushing method, device, server and storage medium
CN104270444A (en) Method capable of being used for configuring mobile phone application menu
KR101351867B1 (en) Method of handling step execution result in software and application control management object
CN106656936B (en) A kind of access control method, PRP entity, PDP entity and PEP entity
CN107111662A (en) Systems, devices and methods for processing data
US20210144629A1 (en) Wireless communication core network and method for analyzing user equipment mobility in the same
CN112800440A (en) Dynamic watermark adding processing method and device
CN105653534A (en) Method and device for processing data
CN111259037A (en) Data query method and device based on rule configuration, storage medium and terminal
CN110582998A (en) Group communication method and device, computer storage medium and computer equipment
CN111030844A (en) Method and device for establishing flow processing framework
CN105659643A (en) Method and apparatus for managing communications with multiple identification profiles
CN113055419A (en) Information sending method and device

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant