CN112269915B

CN112269915B - Service processing method, device, equipment and storage medium

Info

Publication number: CN112269915B
Application number: CN202011191803.1A
Authority: CN
Inventors: 李立夫; 王杰; 陈策; 邓柯
Original assignee: Chengdu Quality Starker Technology Co Ltd
Current assignee: Chengdu Quality Starker Technology Co Ltd
Priority date: 2020-10-30
Filing date: 2020-10-30
Publication date: 2023-08-25
Anticipated expiration: 2040-10-30
Also published as: CN112269915A

Abstract

The embodiment of the invention provides a service processing method, a device, equipment and a storage medium, aiming at improving the convenience of service processing. The service processing method is applied to middleware, and comprises the following steps: receiving a first message sent by a target user terminal, wherein the first message carries a transaction identifier; searching a second message carrying the same transaction identifier according to the transaction identifier carried by the first message; generating one or more first transactions according to the second message and the first message; the one or more first transactions are submitted to a blockchain network for execution. In the invention, during the service development period, the user does not need to construct the transaction in person, but the middleware automatically generates the transaction by sending the first message to the middleware, so that the convenience of service development is improved, and the service processing efficiency is improved.

Description

Service processing method, device, equipment and storage medium

Technical Field

The present invention relates to the field of communications technologies, and in particular, to a service processing method, apparatus, device, and storage medium.

Background

The block chain technology is built on a transmission network (also called a block chain network), distributed node equipment (hereinafter called nodes for short) in the transmission network realizes generation, verification and uplink storage of block data by running a block chain program, finally realizes a data tamper-proof mechanism, and provides a safe and reliable technical new idea for service development.

The blockchain technology can be applied to various business scenes, such as financial field, electronic commerce field, commodity or raw material tracing field, electronic certificate storing field and the like, and can be used for developing business due to the fact that the blockchain technology realizes a data tamper-proof mechanism, so that the trust crisis among parties involved in the business can be solved.

In the related art, in order to develop a service based on a blockchain network, a user needs to construct one or more transactions related to the service by operating his or her user side device, and then submit the transactions to the blockchain network for execution. However, because of the complex data structure of the transaction, and the need for the user to not only manually construct the transaction, but also to look up data related to the business (e.g., vendor account, contract address, etc.) during construction of the transaction. The process of constructing transactions is thus too complex for the user, resulting in inefficient business processing.

Disclosure of Invention

The embodiment of the invention aims to provide a service processing method, a device, equipment and a storage medium, aiming at improving the convenience of service processing. The specific technical scheme is as follows:

in a first aspect of an embodiment of the present invention, a service processing method is provided, applied to middleware, where the method includes:

Receiving a first message sent by a target user terminal, wherein the first message carries a transaction identifier;

searching a second message carrying the same transaction identifier according to the transaction identifier carried by the first message;

generating one or more first transactions according to the second message and the first message;

the one or more first transactions are submitted to a blockchain network for execution.

In a second aspect of the embodiment of the present invention, there is provided a service processing apparatus, applied to a middleware, the apparatus including:

the message receiving module is used for receiving a first message sent by a target user terminal, wherein the first message carries a transaction identifier;

the message searching module is used for searching a second message carrying the same transaction identifier according to the transaction identifier carried by the first message;

the transaction generation module is used for generating one or more first transactions according to the searched second message and the first message;

and the transaction submitting module is used for submitting the one or more first transactions to the blockchain network for execution.

In a third aspect of the embodiments of the present invention, there is provided an electronic device including a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory perform communication with each other through the communication bus;

The memory is used for storing a computer program;

the processor is configured to implement the service processing method provided by any embodiment of the present invention when executing the program stored in the memory.

In a fourth aspect of the embodiments of the present invention, there is provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the service processing method provided by any of the embodiments of the present invention.

In the invention, in order to develop the service, the user does not need to manually construct the transaction, but encapsulates the service parameters into the first message and sends the first message to the middleware. After the middleware receives the first message, searching a second message carrying the same transaction identifier according to the transaction identifier carried by the first message. Thus, the middleware can acquire the history data related to the service from the searched second message. Finally, the middleware automatically generates one or more first transactions according to the searched second message and the received first message, and submits the transactions to the blockchain network for execution. In the invention, the user does not need to manually construct the transaction during the service development period, so that the convenience of service development is improved, and the service processing efficiency is improved.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below. It is evident that the drawings in the following description are only some embodiments of the present invention and that other drawings may be obtained from these drawings by those of ordinary skill in the art without inventive effort.

Fig. 1 is a schematic diagram of a service processing method based on a service processing system according to an embodiment of the present invention;

FIG. 2 is a flow chart of a business processing method according to an embodiment of the present invention;

fig. 3 is a schematic diagram of a service processing apparatus according to an embodiment of the present invention;

fig. 4 is a schematic diagram of an electronic device according to an embodiment of the invention.

Detailed Description

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. It will be apparent that the described embodiments are some, but not all, embodiments of the invention. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.

In the related art, when a user performs a service using a blockchain network, it is generally required to construct one or more transactions related to the service, and then submit the constructed one or more transactions to the blockchain network for execution.

Optionally, in some embodiments, the process of executing the transaction using the blockchain network includes: the real data generated in the physical world is constructed into a transaction format supported by the blockchain network and distributed to the blockchain network; after each node of the blockchain network receives the transaction, executing the transaction, and generating a block according to the transaction and the execution result of the transaction; the nodes mutually agree on the blocks generated by each other, and each node adds the respective block to the end of the respective stored blockchain under the condition that the agreement is reached.

It should be noted that, in the embodiment of the present invention, the process of executing the transaction on the blockchain network is not limited to the above embodiment. Other technical solutions well known to those skilled in the art may be adopted in addition to the above embodiments.

In view of this, the present invention proposes a service processing method, apparatus, device, and storage medium by the following embodiments, aiming at improving convenience of service processing.

Referring to fig. 1, fig. 1 is a schematic diagram of a service processing method based on a service processing system according to an embodiment of the present invention. As shown in fig. 1, the service processing system includes: a blockchain network, a plurality of middleware, and a plurality of clients. The client is in communication connection with middleware which in turn is in communication connection with any node or designated node within the blockchain network. Thus, the client side realizes communication with the blockchain network through middleware.

Specifically, the user side sends a message to the middleware, so that information is transferred to the middleware. The middleware analyzes the message sent by the user terminal into one or more transactions and submits the transactions to the blockchain network, so that information is transferred to the blockchain network. In addition, middleware obtains information from the blockchain network through synchronizing new blocks generated by the blockchain network or synchronizing a ledger database of the blockchain network. The middleware assembles the information obtained from the blockchain network into a message, and returns the message to the user terminal, thereby realizing information transmission to the user terminal. Thus, the client side realizes communication with the blockchain network through middleware.

The middleware encapsulates the complex interface of the blockchain network into a simple and standard financial service interface and provides the interface to the user terminal, so that the interaction difficulty between the user terminal and the blockchain network is reduced.

The middleware may be a software program or a hardware device. In the case where the middleware is a software program, the middleware may be run in a node device of the blockchain network, may be run in a computer on the user side, and may be run in a computer between the blockchain network and the user side.

The user side may be a software program or a hardware device. In the case that the client is a software program, the client may be running in a node device of the blockchain network, or may be running separately in a computer outside the blockchain network. If the user terminal runs in a certain node device of the blockchain network, the node device corresponding to the blockchain network is operated and maintained by the user, and the user installs the client terminal in the node device at the same time.

Alternatively, in some embodiments, each client corresponds to one middleware, and one middleware may correspond to a plurality of clients. Each user terminal realizes communication with the blockchain network through the corresponding middleware.

In the specific implementation, different user groups respectively correspond to different middleware, so that each user group can manage and maintain the middleware by itself, and the safety of the middleware is improved. For ease of understanding, multiple branches of a bank may be used as a community of users, for example. For example, the multiple branches of bank a collectively correspond to middleware a, the multiple branches of bank B collectively correspond to middleware B, and the multiple branches of bank C collectively correspond to middleware C. In this scenario, by implementing the following information transfer method, when each bank processes a service by using the blockchain network, information can be conveniently transferred between different banks (for example, between bank a and bank B) through the blockchain network.

In the above, the structure of the service processing system provided by the present invention is described. Hereinafter, a service processing method based on the service processing system will be described.

As shown in fig. 1, when the second user end generates the service requirement, a second message is sent to the second middleware, where the second message includes the service type identifier.

For ease of understanding, the second client sends a second message to the second middleware when the second client needs to initiate a sales offer on the blockchain network. Since the second message is a message for initiating a sales offer, the service type identifier included in the second message reflects that: the second message is used for initiating the sales of the single offer. For ease of understanding, the service type identifier contained in the second message is, for example, an SMTO.

In addition, the second message may further include a service parameter, a contract template number, contract data, and the like. Wherein the service parameter is information related to the service, for example, the service parameter includes: account address of the vendor, amount of transactions contracted in the vendor, etc. The contract template number is used to indicate the contract module that the middleware needs to select when generating the smart contract. Contract data is data that middleware needs to populate a contract template when generating a smart contract, e.g., contract data includes: the contract method (i.e., contract code), preconditions (e.g., time conditions, transaction amount conditions, buyer rights conditions, etc.) that the contract method needs to satisfy before execution.

As shown in fig. 1, after receiving the second message sent by the second user end, the second middleware parses the second message into one or more second transactions. Each second transaction carries the same message identifier, at least one second transaction carries the service type identifier contained in the second message, and at least one second transaction carries the transaction identifier of the second message.

Optionally, in some embodiments, after receiving the second message, the second middleware generates a unique message identifier for the second message. For example, in order to generate the unique message identifier, the second middleware may take data such as a timestamp, a number of the second middleware, a universal unique identifier (Universally Unique Identifier, UUID) and the like as input parameters, output a series of hash values through calculation of a hash algorithm, and finally take the first n bits (for example, the first 25 bits) of the hash values as the message identifier.

Or alternatively, in other embodiments, the second message sent by the second user terminal itself includes a message identifier. The message identifier is generated by the second user side for the second message, and the specific generating mode can refer to the above.

Optionally, in some embodiments, after receiving the second packet, the second middleware determines whether the second packet carries the transaction identifier. If the second message does not carry the transaction identifier, the second middleware generates a unique transaction identifier for the second message. For generating the transaction identifier with uniqueness, reference may be made to the above manner of generating the message identifier, and for avoiding repetition, details are not described here.

In the invention, the plurality of messages with the same transaction identifier are a plurality of messages for processing the same transaction or a plurality of messages for processing a plurality of related transactions. The first message sent out of a plurality of messages with the same transaction identifier is generally used for issuing an intelligent contract, and the message does not carry the transaction identifier. And after the middleware receives the message, generating a transaction identifier for the message. And the other messages after the message carry the transaction identifier. As such, multiple messages for processing the same transaction, or multiple messages for processing multiple associated transactions, may be associated with each other by carrying the same transaction identification. For specific implementation of the technical solution in this section, reference may be made to the following, which is not described herein.

Or alternatively, in other embodiments, each second message received by the second middleware itself includes a transaction identifier that the second client generates for the second message.

Optionally, in some specific embodiments, a plurality of message parsing policies are preset in the second middleware, each message parsing policy corresponds to a service type identifier, and is used for parsing a message including the corresponding service type identifier to obtain one or more transactions related to the corresponding service type.

And after the second middleware receives a second message sent by the second user terminal, reading a service type identifier from the second message, and determining a message analysis strategy corresponding to the service type identifier from a plurality of preset message analysis strategies according to the read service type identifier. And then, the second middleware reads data from the second message based on the determined message analysis strategy, and fills the read data into a transaction template defined by the message analysis strategy, so that a second transaction is generated.

In particular, one message parsing policy is actually a section of computer program, and the second middleware executes the message parsing policy by running the section of computer program.

The message analysis strategy is at least used for limiting the message analysis operation as follows:

1. the message analysis strategy defines a plurality of transaction templates, the respective transaction types of the transaction templates are determined, the time sequence relationship among the transaction templates is also determined, and each transaction template comprises one or more empty fields for filling service parameters;

2. for the corresponding transaction of each transaction module, defining the required business parameters; and for each service parameter required for the transaction, defining which field of the message the service parameter is acquired from, and filling the acquired service parameter into which empty field of the transaction template.

For easy understanding, following the above example, after the second middleware receives the second message sent by the second user terminal, the second middleware first reads the service type identifier SMTO from the second message in response to the second message. And then, a message analysis strategy X corresponding to the service type identifier SMT0 is determined from a plurality of preset message analysis strategies by taking the service type identifier SMTO as an index. And then analyzing the second message according to the determined message analysis strategy X.

Specifically, the message parsing policy X defines:

1. The system comprises three transaction templates, namely a transaction template m, a transaction template p and a transaction template r, wherein the type of the transaction template m is contract issuing transaction;

2-1, when constructing a transaction m (i.e. a contract issuing transaction), reading a contract template number from a 10 th field of a second message, calling a contract template corresponding to the contract template number, then reading a contract method from 11 th to 20 th fields of the second message, filling the contract method into a first empty position of the contract template, reading preconditions from 21 st to 25 th fields of the second message, and filling the preconditions into a second empty position of the contract template, thereby generating an intelligent contract to be issued; finally, the smart contract is filled into the 15 th to 160 th fields of the transaction template m to generate a transaction m.

2-2, business parameters such as asset type, asset amount and the like need to be contained in the transaction p; acquiring asset type parameters from the 31 st field of the second message, and filling the acquired asset type parameters into the 3 rd field of the transaction template p; the asset amount parameter is obtained from the 32 nd and 33 th fields of the second message and the obtained asset amount parameter is filled into the 4 th and 5 th fields of the transaction template p to generate the transaction p.

It should be noted that the specific data (such as service type identifier, transaction number, service parameter, field number, etc.) referred to in the above examples are only illustrative examples. During actual implementation of the invention, the actual data involved may be the same as or different from the data in the examples described above.

It should be further noted that the above limitation of the message parsing policy to the message parsing operation is merely an example. Any modifications, equivalent substitutions, improvements, or the like, which are within the spirit and principles of the examples described above, are intended to be included within the scope of the present invention.

Optionally, in some embodiments, after the second middleware parses the second message into a plurality of second transactions. And the second middleware fills the message identifier which is generated in advance for the second message into each second transaction. Thus, the plurality of second transactions parsed by the second message carry the same message identification.

In addition, the second middleware also fills the service type identifier contained in the second message into each second transaction, or the second middleware fills the service type identifier contained in the second message into part of the second transactions.

In addition, the second middleware also fills the transaction identifier of the second message into each second transaction, or the second middleware fills the transaction identifier of the second message into part of the second transactions.

As described in fig. 1, the second middleware, after parsing out one or more second transactions, may send each second transaction to the key management system, causing the key management system to sign the second transaction.

In specific implementation, the second message sent by the second user terminal includes the user identifier of the second user terminal. And after the second middleware analyzes the second transaction, the second transaction and the user identification contained in the second message are sent to the key management system. The key management system stores private keys of a plurality of users. After the key management system receives the second transaction and the user identifier sent by the second middleware, searching a private key corresponding to the user identifier by taking the user identifier as an index, and then signing the second transaction by using the searched private key. Finally, the key management system returns the signed second transaction to the first middleware.

As shown in fig. 1, after the second middleware obtains the signed second transactions, the signed second transactions are submitted to the blockchain network one by one for execution according to the transaction time sequence relationship defined by the message analysis policy. For a specific manner in which the blockchain network performs the second transaction, see above, for simplicity of the drawing, the specific manner in which the blockchain network performs the transaction is not shown in fig. 1.

As shown in fig. 1, the first middleware continuously synchronizes block data generated by the blockchain network and obtains a second transaction from the synchronized block data. The first middleware returns a second message according to a plurality of second transactions carrying the same message identification.

Optionally, in some embodiments, the first middleware stores the second transaction after reading the second transaction from the block data. In addition, the first middleware detects the message identifier carried by each second transaction, and takes a plurality of second transactions carrying the same message identifier as a group of second transactions.

Optionally, in some specific embodiments, a plurality of message grouping strategies are preset in the first middleware, each message grouping strategy corresponds to one service type identifier, and is used for grouping a group of second transactions carrying the corresponding service type identifier, so as to group the second messages.

And after the first middleware acquires a group of second transactions, reading the service type identifier carried by the second transactions from any one of the second transactions in the group of second transactions. And the first middleware determines a message grouping strategy corresponding to the service type identifier from a plurality of preset message grouping strategies according to the read service type identifier. And then, the second middleware reads data for returning the second message from the group of second transactions based on the determined message returning strategy, so that the second message is returned.

In particular, a message grouping policy is actually a section of computer program, and the first middleware executes the message grouping policy by running the section of computer program.

The message grouping strategy is at least used for limiting the message grouping operation as follows:

1. returning the data needed to be contained in the message header of the second message; and for each data that the header needs to contain, defining which field of which second transaction to obtain the data from, and defining which field of the header to fill the data into;

2. returning the service parameters required to be contained in the message body of the second message; and for each service parameter that the message body needs to contain, defining which field of which second transaction to obtain the service parameter from, and defining which field of the message body to fill the service parameter into.

It should be noted that the above limitation of the message grouping policy to the message grouping operation is merely an example. Any modifications, equivalent substitutions, improvements, or the like, which are within the spirit and principles of the examples described above, are intended to be included within the scope of the present invention.

As shown in fig. 1, if the plurality of second transactions carrying the same message identifier include a contract release transaction, the first middleware reads a contract address from the contract release transaction. And the first middleware also reads the transaction identifier carried by the second transaction from any one of a plurality of second transactions carrying the same message identifier. Finally, the first middleware associates the read contract address with the transaction identification.

In specific implementation, a plurality of association relations are stored in the first middleware, and each association relation represents: an association between a transaction identity and a contract address. The first middleware may invoke these associations when subsequently generating a first transaction from the first message.

As shown in fig. 1, the first middleware further fills the read transaction identifier into the second packet that is returned, so that the first user side can obtain the transaction identifier from the second packet after receiving the second packet.

In particular, the first middleware may fill the transaction identifier into a specified field of the header or the trailer of the second message, where the specified field is specifically used for recording the transaction identifier.

In addition, optionally, in some embodiments, the first middleware may further generate a packet identifier for the second packet, and fill the generated packet identifier into the second packet.

Additionally, optionally, in some embodiments, the first middleware may further populate the second message with the service type identifier read in advance from the transaction.

As shown in fig. 1, the first middleware sends the assembled second message to the first client. In addition, the first middleware stores the assembled second message.

Optionally, in some embodiments, as described above, each middleware corresponds to a plurality of clients respectively. The first middleware sends a second message to each first user end corresponding to the first middleware after the second message is returned to form a second message, and data such as transaction identification, message identification, service type identification and the like are filled in the second message.

Alternatively, in other embodiments, the first client may subscribe to a portion of the messages of the second client in advance, where subscription information of each first client is recorded in the first middleware. Specifically, if the subscription information of a certain first ue includes the respective user identities of the second ue b1, the second ue b2 and the second ue b5, the first ue is equivalent to subscribing the respective messages of the second ue b1, the second ue b2 and the second ue b 5.

In addition, the second message sent by the second user terminal to the second middleware includes the user identifier of the second user terminal. One or more second transactions parsed by the second message inherit the user identification contained in the second message. After the second transactions are returned by the first middleware to form a second message, the first middleware reads the user identification from the second transactions. And then, the first middleware judges whether the subscription information of the first user terminal contains the user identifier according to each first user terminal corresponding to the first middleware, and if so, the second message assembled is sent to the first user terminal.

For ease of understanding, it is assumed that, for example, after the first middleware assembles the second message according to the plurality of second transactions, the first middleware reads the user identifier b2 of the second user terminal from the plurality of second transactions. Then, the first middleware judges whether the subscription information of each first user terminal (a 1 to a 10) corresponding to the first middleware comprises the user identification or not. If the subscription information of the first user terminal a1 does not contain the user identifier b2, the first middleware does not send the assembled second message to the first user terminal a1. If the subscription information of the first user terminal a2 includes the user identifier b2, the first middleware needs to send the assembled second message to the first user terminal a2.

As shown in fig. 1, when a service requirement is generated, a first user end sends a first message to a first middleware, where the first message includes a service type identifier, a transaction identifier and a user identifier of the first user end.

The transaction identifier in the first message is from a second message received in advance by the first user terminal. In specific implementation, after receiving each second message, the first user side stores the second message, analyzes the second message, and displays the analysis result to the user. When a user selects one second message from the plurality of second messages and needs to execute subsequent association actions on the second message, the user executes preset operations (such as touch control, mouse control, keyboard control, voice input and the like) on the first user terminal, so that the first user terminal generates a first message, the first message carries a transaction identifier, and the transaction identifier is equal to the transaction identifier carried by the second message selected by the user.

For ease of understanding, it is assumed that the second client b1 sends a second message x to the second middleware for initiating the sales offer_x. After the first middleware passes through the above processing steps, a second message x is returned, and the original second message x and the returned second message x carry the same transaction identifier. After the first middleware sends the assembled second message x to the first user terminal, the first user terminal can display the content of the second message x.

Assume again that the second client b2 sends a second message y for initiating the sales offer_y to the second middleware. After the first middleware passes through the above processing steps, a second message y is returned, and the original second message y and the returned second message y carry the same transaction identifier. After the first middleware sends the assembled second message y to the first user terminal, the first user terminal can display the content of the second message y.

If the user of the first user terminal wants to initiate the buying bill bid for the second message y (i.e. initiate buying bill bid for selling bill offer_y), the user executes a preset operation on the first user terminal, so that the first user terminal generates a first message, and fills the transaction identifier carried by the second message y into the first message.

In addition, if the plurality of first transactions analyzed by the first middleware include target transactions needing to call intelligent contracts, the first middleware uses transaction identifiers carried by the first messages as indexes, and determines contract addresses corresponding to the transaction identifiers by inquiring a plurality of pre-stored association relations. The first middleware then populates the determined contract address to the target transaction.

As shown in fig. 1, after receiving a first message sent by a first user end, a first middleware searches a second message carrying the same transaction identifier according to the transaction identifier carried by the first message.

As shown in fig. 1, the first middleware generates one or more first transactions according to the second message and the received first message.

In specific implementation, the same way as the second middleware analyzes the second message is adopted, a plurality of message analysis strategies are preset in the first middleware, each message analysis strategy corresponds to a service type identifier respectively, and the message analysis strategies are used for analyzing the message containing the corresponding service type identifier so as to obtain one or more transactions related to the corresponding service type.

After the first middleware receives a first message sent by a first user terminal, reading a service type identifier from the first message, and determining a message analysis strategy corresponding to the service type identifier from a plurality of preset message analysis strategies according to the read service type identifier. And then, the first middleware reads data from the searched second message and the first message based on the determined message analysis strategy, and fills the read data into a transaction template defined by the message analysis strategy, so as to generate a first transaction.

2. for the corresponding transaction of each transaction module, defining the required business parameters; and for each service parameter required for the transaction, defining which field of which message the service parameter is acquired from, and filling the acquired service parameter into which empty field of the transaction template.

It should be noted that the above limitation of the message parsing policy to the message parsing operation is merely an example. Any modifications, equivalent substitutions, improvements, or the like, which are within the spirit and principles of the examples described above, are intended to be included within the scope of the present invention.

For easy understanding, along with the above example, the user of the first user terminal wants to initiate a bid for the second message y (i.e. initiate a bid for the sell_y), and the user performs a preset operation on the first user terminal, so that the first user terminal generates a first message, where the first message carries a transaction identifier, and the transaction identifier is equal to the transaction identifier carried by the second message y.

After the first middleware receives the first message, the second message y is found according to the transaction identifier carried by the first message. And then, the first middleware reads the business parameters for generating the transaction from the first message and the second message y, and fills the read business parameters into a transaction template defined by a message analysis strategy, so that one or more first transactions are generated. The service parameters read from the second message y include, but are not limited to: the address of the vendor of the single offer.

In the invention, when the first middleware analyzes the first message into the transaction, the second message carrying the same transaction identifier can be automatically obtained according to the transaction identifier carried by the first message. The first middleware then generates one or more first transactions based on the content of the first message and the content of the second message. Therefore, when the user generates the first message by utilizing the first user terminal, the user does not need to encapsulate too many service parameters by indicating the corresponding transaction identifier. The method is beneficial to reducing the data volume of the first message, reducing the network consumption and further improving the convenience of service processing.

As shown in fig. 1, after generating one or more first transactions, the first middleware sends the first transaction and the user identifier carried by the first message to the key management system for each first transaction, and receives the first transaction signed by the private key of the first user side returned by the key management system.

In particular, the key management system stores private keys of a plurality of users. After the key management system receives the first transaction and the user identifier sent by the first middleware, the private key corresponding to the user identifier is searched by taking the user identifier as an index, and then the searched private key is used for signing the first transaction. Finally, the key management system returns the signed first transaction to the first middleware.

As shown in fig. 1, after signing the first transaction by using the key management system, the first middleware submits the signed first transaction to the blockchain network for execution one by one according to the time sequence relationship of the plurality of first transactions.

When the first transactions are submitted one by one, the current first transaction is submitted to the blockchain network for execution after the execution result of the last first transaction is received.

For ease of understanding, assume that the first middleware generates a plurality of first transactions with a timing relationship as follows: first transaction x, first transaction y, and first transaction z. The first middleware first submits the signed first transaction x to the blockchain network for execution during submission of the first transaction. And when the first middleware receives an execution result of the first transaction x returned by the blockchain network, submitting the signed first transaction y to the blockchain network for execution. And when the first middleware receives an execution result of the first transaction y returned by the blockchain network, submitting the signed first transaction z to the blockchain network for execution.

By submitting the transactions in the manner, the blockchain network executes each first transaction in turn strictly according to the time sequence relation of each first transaction, so that the failure of the whole business processing caused by the disorder of the execution sequence of the first transactions can be avoided.

In addition, as shown in fig. 1, the second middleware may also continuously synchronize the block data of the blockchain network. And the second middleware can acquire the first transaction from the block data, and according to the first transaction carrying the same message identification, the second middleware can return a first message, and then send the returned first message to the second user terminal. Therefore, the second user side can know that the issued sales bill offer is purchased by the corresponding sales bill bid according to the first message. To simplify the drawing, the technical content of this section is only schematically represented by a dashed arrow in fig. 1.

In the above, the present invention provides a service processing method based on a service processing system according to some preferred embodiments. In the following, other embodiments of the present invention provide other service processing methods. It should be noted that the following embodiments may be referred to with the above embodiments. It should be further noted that, during implementation, the service processing method set forth in the following embodiments does not necessarily depend on the service processing system shown in fig. 1.

Referring to fig. 2, fig. 2 is a flowchart of a service processing method according to an embodiment of the present invention. The service processing method can be applied to middleware, which can be a software program or a hardware device between the blockchain network and the user terminal. As shown in fig. 2, the service processing method includes the steps of:

step S21: and receiving a first message sent by a target user terminal, wherein the first message carries a transaction identifier.

Step S22: and searching a second message carrying the same transaction identifier according to the transaction identifier carried by the first message.

Step S23: and generating one or more first transactions according to the searched second message and the first message.

Step S24: the one or more first transactions are submitted to a blockchain network for execution.

In the invention, the plurality of messages with the same transaction identifier are a plurality of messages for processing the same transaction or a plurality of messages for processing a plurality of related transactions.

Optionally, in some specific embodiments, as described above, the first packet further carries a service type identifier. In executing the above step S23, the following sub-steps are specifically performed:

Substep S23-1: and determining a message analysis strategy corresponding to the service type identifier from a plurality of preset message analysis strategies according to the service type identifier carried by the first message.

Substep S23-2: based on the determined message analysis strategy, reading data from the searched second message and the first message, and filling the read data into a transaction template defined by the message analysis strategy, thereby generating a first transaction.

For the detailed description of the substep S23-1 and the substep S23-2, reference should be made to the foregoing preferred embodiments, and no further description is given here for avoiding repetition.

Optionally, in some embodiments, in a case where the plurality of first transactions are generated according to the first message and the second message, the message parsing policy further defines a timing relationship between the plurality of first transactions. In executing the above step S24, specifically: and submitting the first transactions to the blockchain network for execution one by one according to the time sequence relation of the plurality of first transactions, wherein when the first transactions are submitted one by one, the current first transaction is submitted to the blockchain network for execution after the execution result of the last first transaction is received.

In the invention, the first transaction is submitted through the specific implementation manner, so that the blockchain network executes each first transaction in sequence strictly according to the time sequence relation of each first transaction, and the failure of the whole business processing caused by the disorder of the execution sequence of the first transaction can be avoided.

For the specific description of the above embodiments, reference may be made to the foregoing preferred embodiments, and in order to avoid repetition, details are not repeated here.

Optionally, in some embodiments, as described above, the first packet further carries a user identifier of the target ue. Before executing the step S24, the middleware may further send, for each first transaction, the first transaction and the user identifier of the target user side to the key management system, and receive the first transaction signed with the private key of the target user side returned by the key management system. In executing the above step S24, specifically: the middleware submits the signed one or more first transactions to a blockchain network for execution.

In the invention, the first transaction is generated by the middleware rather than the user side, so the first transaction cannot be signed on the user side. In order to improve the safety of the business processing process, after the middleware generates the first transaction, the key management system is called to sign the first transaction, so that the aim of improving the safety of the business processing process is fulfilled.

Optionally, in some embodiments, as previously described, the middleware further performs the steps of: acquiring second transactions from the blockchain network, wherein each second transaction carries a message identifier, a plurality of second transactions analyzed by the same second message carry the same message identifier, and at least one second transaction in the plurality of second transactions analyzed by the same second message carries the transaction identifier of the second message; according to a plurality of second transactions carrying the same message identification, corresponding second messages are formed in a back-grouping mode; reading the transaction identifier carried by the second transaction from any one of the second transactions carrying the same message identifier, and filling the read transaction identifier into the returned second message; and storing the second message filled with the transaction identifier and sending the second message to the target user terminal.

In specific implementation, at least one second transaction of the plurality of second transactions parsed by the same second message carries a service type identifier of the second message. In order to return a corresponding second message, specifically: the middleware reads the service type identifier carried by the second transaction from any one of the second transactions carrying the same message identifier; the middleware determines a message grouping strategy corresponding to the service type identifier from a plurality of preset message grouping strategies according to the read service type identifier; and the middleware reads data for returning the second message from the plurality of second transactions carrying the same message identification based on the determined message returning strategy so as to return the second message.

In the invention, each second transaction carries the message identifier, and a plurality of second transactions analyzed by the same second message carry the same message identifier. Therefore, the plurality of second transactions carrying the same message identifier correspond to the same second message, and further correspond to the service to be processed by the second message. Thus, according to the second message which is returned by a plurality of second transactions carrying the same message identification, the more complete service information can be reflected. And then the second message returned is sent to the target user terminal, so that the target user terminal can obtain the service information simply, conveniently and rapidly by analyzing the second message. Therefore, by implementing the method and the device, the convenience of information transmission can be improved, and the user experience is improved.

Optionally, in some specific embodiments, the second message is used for issuing a sales order, and the first message is used for issuing a purchase order, and if the first message and the second message carry the same transaction identifier, the purchase order issued by the first message and the sales order issued by the second message are a pair of orders with a purchase-sale relationship.

Or alternatively, in other specific embodiments, the second message is used for issuing a purchase order, and the first message is used for issuing a sales order, and if the first message and the second message carry the same transaction identifier, the sales order issued by the first message and the purchase order issued by the second message are a pair of orders with a purchase-sale relationship.

Based on the same inventive concept, the embodiment of the invention also provides a service processing device. Referring to fig. 3, fig. 3 is a schematic diagram of a service processing apparatus according to an embodiment of the present invention, where the apparatus is applied to middleware.

As shown in fig. 3, the apparatus includes:

the message receiving module 31 is configured to receive a first message sent by a target user terminal, where the first message carries a transaction identifier;

the message searching module 32 is configured to search a second message carrying the same transaction identifier according to the transaction identifier carried by the first message;

A transaction generating module 33, configured to generate one or more first transactions according to the second message and the first message;

a transaction submission module 34 for submitting the one or more first transactions to a blockchain network for execution.

Optionally, in some specific embodiments, the first packet further carries a service type identifier; the transaction generation module includes:

the analysis strategy determining unit is used for determining a message analysis strategy corresponding to the service type identifier from a plurality of preset message analysis strategies according to the service type identifier carried by the first message;

the analysis strategy executing unit is used for reading data from the searched second message and the first message based on the determined message analysis strategy, and filling the read data into a transaction template defined by the message analysis strategy so as to generate a first transaction.

Optionally, in some specific embodiments, in a case that a plurality of first transactions are generated, the message parsing policy further defines a timing relationship between the plurality of first transactions; the transaction submitting module is specifically used for: and submitting the first transactions to the blockchain network for execution one by one according to the time sequence relation of the plurality of first transactions, wherein when the first transactions are submitted one by one, the current first transaction is submitted to the blockchain network for execution after the execution result of the last first transaction is received.

Optionally, in some specific embodiments, the first packet further carries a user identifier of the target user end; the apparatus further comprises:

the transaction signing module is used for sending the first transaction and the user identification of the target user side to the key management system for each first transaction before submitting the one or more first transactions to the blockchain network for execution, and receiving the first transactions which are returned by the key management system and signed by the private key of the target user side;

the transaction submitting module is specifically configured to: submitting the signed one or more first transactions to a blockchain network for execution.

Optionally, in some embodiments, the apparatus further comprises:

the transaction acquisition module is used for acquiring second transactions from the blockchain network, wherein each second transaction carries a message identifier, a plurality of second transactions analyzed by the same second message carry the same message identifier, and at least one second transaction in the plurality of second transactions analyzed by the same second message carries the transaction identifier of the second message;

the message group returning module is used for returning corresponding second messages according to a plurality of second transactions carrying the same message identifications;

The transaction identifier filling module is used for reading the transaction identifier carried by the second transaction from any one of the plurality of second transactions carrying the same message identifier, and filling the read transaction identifier into the returned second message;

and the message sending module is used for storing the second message filled with the transaction identifier and sending the second message to the target user terminal.

Optionally, in some embodiments, at least one second transaction of the plurality of second transactions parsed by the same second message carries a service type identifier of the second message; the message group returning module comprises:

a service type identifier reading unit, configured to read a service type identifier carried by the second transaction from any one of the plurality of second transactions carrying the same message identifier;

the message grouping strategy corresponding to the service type identifier is determined from a plurality of preset message grouping strategies according to the read service type identifier;

and the grouping strategy execution unit is used for reading data for grouping the second messages from the plurality of second transactions carrying the same message identifiers based on the determined message grouping strategy so as to group the second messages.

Optionally, in some specific embodiments, the second message is used for issuing a sales order, and the first message is used for issuing a purchase order, and if the first message and the second message carry the same transaction identifier, the purchase order issued by the first message and the sales order issued by the second message are a pair of orders with a purchase-sale relationship;

or,

the second message is used for issuing a buying bill, the first message is used for issuing a selling bill, and if the first message and the second message carry the same transaction identifier, the selling bill issued by the first message and the buying bill issued by the second message are a pair of orders with buying and selling relations.

For the device embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and reference is made to the description of the method embodiments for relevant points.

Based on the same inventive concept, the embodiment of the invention also provides an electronic device, as shown in fig. 4, which comprises a processor 401, a communication interface 402, a memory 403 and a communication bus 404, wherein the processor 401, the communication interface 402 and the memory 403 complete communication with each other through the communication bus 404.

The memory 403 is used for storing a computer program;

The processor 401 is configured to implement the following steps when executing a program stored in the memory 403:

Alternatively, the processor 401 is configured to implement the steps of the service processing method provided in the other method embodiments of the present invention when executing the program stored in the memory 403.

The communication bus mentioned by the above electronic device may be a peripheral component interconnect standard (Peripheral Component Interconnect, abbreviated as PCI) bus or an extended industry standard architecture (Extended Industry Standard Architecture, abbreviated as EISA) bus, or the like. The communication bus may be classified as an address bus, a data bus, a control bus, or the like. For ease of illustration, the figures are shown with only one bold line, but not with only one bus or one type of bus.

The communication interface is used for communication between the electronic device and other devices.

The memory may include random access memory (Random Access Memory, RAM) or non-volatile memory (non-volatile memory), such as at least one disk memory. Optionally, the memory may also be at least one memory device located remotely from the aforementioned processor.

The processor may be a general-purpose processor, including a central processing unit (Central Processing Unit, CPU for short), a network processor (Network Processor, NP for short), etc.; but also digital signal processors (Digital Signal Processing, DSP for short), application specific integrated circuits (Application Specific Integrated Circuit, ASIC for short), field-programmable gate arrays (Field-Programmable Gate Array, FPGA for short) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components.

In yet another embodiment of the present invention, a computer readable storage medium is provided, where instructions are stored, which when run on a computer, cause the computer to perform the service processing method according to any of the above embodiments.

In the above embodiments, it may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When loaded and executed on a computer, produces a flow or function in accordance with embodiments of the present invention, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in or transmitted from one computer-readable storage medium to another, for example, by wired (e.g., coaxial cable, optical fiber, digital Subscriber Line (DSL)), or wireless (e.g., infrared, wireless, microwave, etc.). The computer readable storage medium may be any available medium that can be accessed by a computer or a data storage device such as a server, data center, etc. that contains an integration of one or more available media. The usable medium may be a magnetic medium (e.g., floppy Disk, hard Disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., solid State Disk (SSD)), etc.

It is noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.

In this specification, each embodiment is described in a related manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for system embodiments, since they are substantially similar to method embodiments, the description is relatively simple, as relevant to see a section of the description of method embodiments.

The foregoing description is only of the preferred embodiments of the invention and is not intended to limit the scope of the invention. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention are included in the protection scope of the present invention.

Claims

1. A method of service processing, applied to middleware, the method comprising:

submitting the one or more first transactions to a blockchain network for execution;

wherein the generating one or more first transactions according to the second message and the first message includes:

determining a message analysis strategy corresponding to the service type identifier from a plurality of preset message analysis strategies according to the service type identifier carried by the first message;

based on the determined message analysis strategy, reading data from the searched second message and the first message, and filling the read data into a transaction template defined by the message analysis strategy, thereby generating a first transaction.

2. The method of claim 1, wherein the message parsing policy further defines a timing relationship between the plurality of first transactions in the event that the plurality of first transactions are generated; the submitting the one or more first transactions to a blockchain network for execution includes:

and submitting the first transactions to the blockchain network for execution one by one according to the time sequence relation of the plurality of first transactions, wherein when the first transactions are submitted one by one, the current first transaction is submitted to the blockchain network for execution after the execution result of the last first transaction is received.

3. The method of claim 1, wherein the first message further carries a user identifier of a target user terminal; before submitting the one or more first transactions to a blockchain network for execution, the method further includes:

for each first transaction, transmitting the first transaction and a user identifier of a target user side to a key management system, and receiving the first transaction which is returned by the key management system and signed by a private key of the target user side;

the submitting the one or more first transactions to a blockchain network for execution includes:

Submitting the signed one or more first transactions to a blockchain network for execution.

4. A method according to any one of claims 1 to 3, wherein the method further comprises:

acquiring second transactions from the blockchain network, wherein each second transaction carries a message identifier, a plurality of second transactions analyzed by the same second message carry the same message identifier, and at least one second transaction in the plurality of second transactions analyzed by the same second message carries the transaction identifier of the second message;

according to a plurality of second transactions carrying the same message identification, corresponding second messages are formed in a back-grouping mode;

reading the transaction identifier carried by the second transaction from any one of the second transactions carrying the same message identifier, and filling the read transaction identifier into the returned second message;

and storing the second message filled with the transaction identifier and sending the second message to the target user terminal.

5. The method of claim 4 wherein at least one of the plurality of second transactions parsed from the same second message carries a service type identification of the second message; and according to a plurality of second transactions carrying the same message identification, returning a corresponding second message, including:

Reading a service type identifier carried by the second transaction from any one of the plurality of second transactions carrying the same message identifier;

determining a message grouping strategy corresponding to the service type identifier from a plurality of preset message grouping strategies according to the read service type identifier;

and based on the determined message grouping strategy, reading data for grouping the second messages from the plurality of second transactions carrying the same message identifiers so as to group the second messages.

6. The method of claim 4, wherein the second message is used to issue a sales order, and the first message is used to issue a purchase order, and if the first message and the second message carry the same transaction identifier, the purchase order issued by the first message and the sales order issued by the second message are a pair of orders with a purchase-sale relationship;

or,

7. A service processing apparatus, for use in middleware, said apparatus comprising:

a transaction submitting module for submitting the one or more first transactions to a blockchain network for execution;

8. The electronic equipment is characterized by comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory are communicated with each other through the communication bus;

The memory is used for storing a computer program;

the processor is configured to implement the method steps of any of claims 1-6 when executing a program stored on a memory.

9. A computer readable storage medium, on which a computer program is stored, characterized in that the program, when being executed by a processor, implements the method steps of any of claims 1-6.