CN112052263A - Method, system, computer device, and readable storage medium for requesting instruction processing - Google Patents

Abstract

The present application relates to a method, system, computer device, and readable storage medium for processing a request instruction, wherein the method for processing a request instruction includes: receiving a request instruction, obtaining an annotation of the request instruction through an interceptor, and storing the annotation with a cache The abstract interface is matched to obtain the processing method of the request instruction, wherein the processing method corresponds to the annotation, the request instruction is processed according to the processing method, and the return value of the request instruction is returned. This application solves the problems that developers need to manually manage the cache and connect to the cache database, increase the development cost, consume a long time, and have low efficiency, realize the automatic management of the cache database, improve the processing efficiency of the request command, and save time. .

Description

Method, system, computer device, and readable storage medium for requesting instruction processing

technical field

The present application relates to the technical field of data processing, and in particular, to a method, system, computer device and readable storage medium for requesting instruction processing.

Background technique

With the development of Internet technology, the content and information on the Internet are becoming more and more complex, the number of Internet users and the number of user visits are increasing, and Internet-based applications need to support more concurrency. At the same time, application servers and Database servers also need to perform more and more computations. However, the resources of the application server are limited, and the number of requests per second the database can accept is also limited.

In related technologies, for example, in some seckill scenarios, in order to avoid the number of goods sold being greater than the estimated sales volume, developers need to manually connect to the remote dictionary service (Remote Dictionary Server, Redis for short), manage the cache and cache expiration, Or manually write distributed locks to provide the greatest possible throughput and allow limited resources to serve more users. However, manually connecting to Redis and managing the cache by developers will increase development costs, take a long time, and be inefficient.

At present, in the related technologies, developers manually connect Redis and manage the cache, which will increase the development cost, take a long time, and have low efficiency, and no effective solution has been proposed yet.

SUMMARY OF THE INVENTION

Embodiments of the present application provide a method, system, computer device, and computer-readable storage medium for processing request instructions, so as to at least solve the problem in the related art that developers manually connect to Redis and manage cache, which increases development costs and takes a long time. , the problem of lower efficiency.

In a first aspect, an embodiment of the present application provides a method for requesting instruction processing, the method comprising:

Receive the request instruction, and obtain the annotation of the request instruction through the interceptor;

Matching the annotation with the cache abstract interface to obtain a processing method for the request instruction, wherein the processing method corresponds to the annotation;

The request instruction is processed according to the processing method, and the return value of the request instruction is returned.

In some of the embodiments, when the annotation is the first annotation, the processing the request instruction according to the processing method includes one of the following:

In the case that the return value of the request instruction exists in the Redis cache, call the Redis cache, and obtain the return value of the request instruction in the Redis cache;

In the case that the return value of the request instruction does not exist in the Redis cache, obtain the return value of the request instruction in the storage medium, set the return value to the Redis cache through serialization, and The configuration properties of the first annotation are set.

In some of these embodiments, the serialization includes at least one of: fastjson serialization, kryo serialization, and JDK serialization.

In some of the embodiments, when the annotation is the second annotation, the processing the request instruction according to the processing method includes:

Load the lua script, obtain distributed locks in the Redis cache, and the configuration attributes of the second annotation include the number of reentrant locks and the interval time;

In the case that the distributed lock exists in the Redis cache, the request instruction is not processed, or, in the case that the distributed lock does not exist in the Redis cache, the request instruction is obtained from the storage medium The return value of the request instruction is requested, and the distributed lock is released.

In some of the embodiments, when the annotation is a third annotation, the processing the request instruction according to the processing method includes:

In the Redis cache, delete the key-value pair, wherein the key of the key-value pair is the key marked by the third annotation.

In some of the embodiments, when the annotation is a fourth annotation, the processing the request instruction according to the processing method further includes:

The fourth annotation is obtained, and the parameters marked by the fourth annotation are used to assemble the keys in the Redis cache.

In some of these embodiments, the configuration parameter of the cache abstraction interface includes an expiration time.

In some of the embodiments, after obtaining the annotation of the request instruction through the interceptor, the method further includes:

In the case that the annotation cannot be matched with the cache abstract interface, the return value of the request instruction is obtained in the storage medium.

In a second aspect, an embodiment of the present application provides a system for requesting instruction processing, the system comprising: a cache module and a core module;

The cache module receives the request instruction, and obtains the annotation of the request instruction through the interceptor;

The core module matches the annotation with the cache abstract interface, and obtains a processing method for the request instruction, wherein the processing method corresponds to the annotation;

The cache module processes the request instruction according to the processing method, and the core module returns a return value of the request instruction.

In a third aspect, an embodiment of the present application provides a computer device, including a memory, a processor, and a computer program stored on the memory and executable on the processor, when the processor executes the computer program Implement any of the methods described above.

In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium on which a computer program is stored, and when the program is executed by a processor, any one of the foregoing methods is implemented.

Compared with the related art, the method for processing a request instruction provided by the embodiment of the present application, by receiving the request instruction, obtaining the annotation of the request instruction through an interceptor, matching the annotation with the cache abstract interface, and obtaining the processing of the request instruction. method, wherein the processing method corresponds to the annotation, the request instruction is processed according to the processing method, and the return value of the request instruction is returned, which solves the need for developers to manually manage the cache and connect to the cache database, which increases development costs and consumes The problem of long time and low efficiency realizes the automatic management of the cache database, improves the processing efficiency of the request command, and saves time.

Description of drawings

The drawings described herein are used to provide further understanding of the present application and constitute a part of the present application. The schematic embodiments and descriptions of the present application are used to explain the present application and do not constitute an improper limitation of the present application. In the attached image:

1 is a schematic diagram of an application environment of a method for processing a request instruction according to an embodiment of the present application;

2 is a flowchart of a method for processing a request instruction according to an embodiment of the present application;

3 is a flowchart of another method for requesting instruction processing according to an embodiment of the present application;

4 is a structural block diagram of a system for requesting instruction processing according to an embodiment of the present application;

5 is a schematic structural diagram of a cache framework for request instruction processing according to an embodiment of the present application;

6 is a flowchart of request instruction processing according to a preferred embodiment of the present application;

FIG. 7 is a schematic diagram of an internal structure of an electronic device according to an embodiment of the present application.

Detailed ways

In order to make the objectives, technical solutions and advantages of the present application clearer, the present application will be described and illustrated below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application, but not to limit the present application. Based on the embodiments provided in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work fall within the protection scope of the present application.

Obviously, the accompanying drawings in the following description are only some examples or embodiments of the present application. For those of ordinary skill in the art, the present application can also be applied to the present application according to these drawings without any creative effort. other similar situations. In addition, it will also be appreciated that while such development efforts may be complex and lengthy, for those of ordinary skill in the art to which the present disclosure pertains, the techniques disclosed in this application Some changes in design, manufacture or production based on the content are only conventional technical means, and it should not be understood that the content disclosed in this application is not sufficient.

Reference in this application to an "embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the application. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor a separate or alternative embodiment that is mutually exclusive of other embodiments. It is explicitly and implicitly understood by those of ordinary skill in the art that the embodiments described in this application may be combined with other embodiments without conflict.

Unless otherwise defined, the technical or scientific terms involved in this application shall have the usual meanings understood by those with ordinary skill in the technical field to which this application belongs. Words such as "a", "an", "an", "the" and the like mentioned in this application do not denote a quantitative limitation, and may denote the singular or the plural. The terms "comprising", "comprising", "having" and any of their variants referred to in this application are intended to cover non-exclusive inclusion; for example, a process, method, system, product or process comprising a series of steps or modules (units) The apparatus is not limited to the steps or units listed, but may further include steps or units not listed, or may further include other steps or units inherent to the process, method, product or apparatus. Words like "connected," "connected," "coupled," and the like referred to in this application are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. The "plurality" referred to in this application refers to two or more. "And/or" describes the association relationship between associated objects, indicating that there can be three kinds of relationships. For example, "A and/or B" can mean that A exists alone, A and B exist at the same time, and B exists alone. The character "/" generally indicates that the associated objects are an "or" relationship. The terms "first", "second", "third", etc. involved in this application are only to distinguish similar objects, and do not represent a specific order for the objects.

The method for processing a request instruction provided by the present application can be applied to the application environment shown in FIG. 1 , which is a schematic diagram of an application environment of the method for processing a request instruction according to an embodiment of the present application, as shown in FIG. 1 . The cache database 102 communicates with the server 104 through the network. The server 104 receives the request instruction, obtains the annotation of the request instruction based on the interceptor, matches the annotation with the cache abstract interface of the cache database 102, obtains the processing method of the request instruction, and the server 104 executes the request instruction according to the processing method. Process and get the return value of the request instruction. The cache database 102 may be a Redis cache database, and the server 104 may be implemented by an independent server or a server cluster composed of multiple servers.

This embodiment provides a method for requesting instruction processing. FIG. 2 is a flowchart of a method for processing a request instruction according to an embodiment of the present application. As shown in FIG. 2 , the method includes the following steps:

Step S201, receiving the request instruction, and obtaining the annotation of the request instruction through the interceptor;

The request instruction in this embodiment may be an instruction for the customer to add the target product to the shopping cart in a seckill scenario. After the request instruction is received, the server may intercept and identify the annotation of the request instruction. In this embodiment, the server may intercept the request instruction using a specific annotation through an interceptor. Interceptors can be implemented based on Aspect Oriented Programming (AOP) using Spring, where AOP is a technology that achieves unified maintenance of program functions through pre-compilation and runtime dynamic agents.

Step S202, matching the annotation with the cache abstract interface to obtain a processing method for the request instruction, wherein the processing method corresponds to the annotation; in the cache database, multiple cache abstract interfaces can be set to match the annotation, and in the cache database If the annotation and the cache abstract interface are successfully matched, the annotation processor can be processed by the developer registered in the xml configuration file, and the processing method of the request instruction corresponding to the annotation can be obtained by identifying the annotation. The processing method may be querying the return value of the request instruction in the cache database, querying the distributed lock in the cache database, or deleting the cache corresponding to the annotation in the cache database. The cache abstraction interface in this embodiment is a collection of multiple abstract methods that define a cache function, wherein “abstract” is a macro description of the common characteristics of a class of things. The cache abstraction interface can improve the reuse rate of programs and increase the Maintainability and Extensibility.

Step S203, process the request instruction according to the processing method, and return a return value of the request instruction. In this embodiment, the return value of the request instruction is a processing result of the request instruction.

Through the above steps S201 to S203, by identifying the annotations used by the request instructions, the cache database can be directly entered to process the request instructions, and developers do not need to manually write codes, which solves the need for developers to manually manage the cache and connect to the cache database. , increases the development cost, takes a long time, and has low efficiency. It realizes the automatic management of the cache database, improves the processing efficiency of the request command, saves time, and improves the consistency and standardization of the program.

In other embodiments, the process of adding annotations to the request instruction is completed before the cache framework acquires the request instruction, for example, it can be completed at the business layer. Further, the method for processing the request instruction can be completed through the cache framework, which can It is used to connect to various business layers. The caching framework obtains request instructions with annotations from the business layer, and processes the request instructions according to the annotations. The annotation can be manually added by the developer for the request instruction, or can be implemented by programming, so as to facilitate the processing of the request instruction.

In some of the embodiments, in the case that the annotation is the first annotation, processing the request instruction includes: in the case that the return value of the request instruction exists in the Redis cache, calling the Redis cache, and obtaining in the Redis cache The return value of the request instruction; or, if the return value of the request instruction does not exist in the Redis cache, obtain the return value of the request instruction in the storage medium, and set the return value to the Redis cache through serialization, And set the configuration properties of the first annotation.

It should be noted that Redis is a Remote Dictionary Server (Redis for short), which is a key-value database. Redis is written using the C language standard formulated by the American National Standards Institute (ANSI), complies with the BSD protocol (Berkeley Software Distribution), supports the network, can be memory-based or persistent, and can provide applications in multiple languages. Program interface (Application Programming Interface, referred to as API). The first annotation in this embodiment may be CacheSet, the first annotation acts on the request instruction, and the return value of the request instruction may be set in the Redis cache. When the first annotation is Cache Set, the configuration properties of the first annotation can be keyHead and expire, where keyHead is the prefix of the key in Redis, expire is the expiration time, and the default value is 600s.

The storage medium in this embodiment may be a temporary or permanent storage area, and serialization is a process of converting state information of an object into a form that can be stored or transmitted. During serialization, objects write their current state to temporary or persistent storage. After writing, the object can be recreated by reading or deserializing the state of the object from storage, and deserialization re-reads the variable contents from the serialized object into memory.

In this embodiment, the first annotation can be used to directly search the Redis cache for the existence of the return value corresponding to the request command. If the return value does not exist in the Redis cache, the return value can be searched in the storage medium, and the The return value is serialized to the Redis cache. Since the read and write speed of Redis is fast, the method in this embodiment can improve the processing speed of the request instruction. On the other hand, serializing the return value to the Redis cache is conducive to fast processing of subsequent request instructions.

In some of these embodiments, serialization includes at least one of: fastjson serialization, kryo serialization, and JDK serialization. Among them, kryo serialization is fast, the size of the serialized data is small, and the performance is good, but the compatibility of kryo serialization is not the best, and cannot support the serialization of all objects; fastjson has better and stable performance; JDK serialization The speed is the slowest, but the stability is the best. In this embodiment, the developer can select different serialization methods by configuring the configuration file, and in this embodiment, the serialization methods can be distinguished by configuring classes. The multiple serialization methods provided in this embodiment provide developers with multiple choices, and developers can choose appropriate serialization methods according to different scenario requirements, which improves the adaptability of the method for processing request instructions.

This embodiment also provides another method for requesting instruction processing. When the annotation is the second annotation, FIG. 3 is a flowchart of another method for requesting instruction processing according to an embodiment of the present application. As shown in FIG. 3 , the method includes the following steps:

Step S301, load the lua script, obtain the distributed lock in the Redis cache, the configuration attributes of the second annotation include the number of reentrant locks and the interval time, the second annotation in this embodiment can be CacheLock, and the annotation can The request directive adds distributed locks. Among them, distributed locks are a way to control synchronous access to shared resources between distributed systems. In this embodiment, the configurable attributes of the annotation CacheLock include key, expire, retry Times and waitTime, where key is the key of the Redis cache, expire is the expiration time, usually, the default is 60s, and retryTimes is the number of reentrant locks , indicating the number of retries of the distributed lock, and waitTime is the interval time, indicating the length of the interval between two retries.

The lua script can be flexibly embedded in the application program, so as to provide flexible extension and customization functions for the application program. In this embodiment, the lua script is used to ensure the atomicity of the distributed lock when the Redis cache operates, where the atomicity is Indicates that multiple database operations that make up a transaction are an indivisible atomic unit. Only when all operations are executed successfully, the entire transaction is committed. If any database operation in the transaction fails, all operations that have been performed must be undone and the database returns. initial state.

Step S302, in the case that the distributed lock exists in the Redis cache, do not process the request instruction, or, in the case that the distributed lock does not exist in the Redis cache, obtain the request instruction from the storage medium. Return value to release the distributed lock. In the case that there is a distributed lock in the Redis cache, it means that the distributed lock is occupied by other threads, and the request instruction in this embodiment needs to be processed. The instruction acquires the distributed lock, and after the return value is acquired, the distributed lock is released.

Through the above steps S301 and S302, the annotation in this embodiment can realize the function of a distributed lock, ensure the atomicity of the distributed lock based on the lua script, and reduce the amount of code to access the cache.

In some of the embodiments, when the annotation is the third annotation, processing the request instruction includes: in the Redis cache, deleting a key-value pair, where the key of the key-value pair is the key marked by the third annotation . The third annotation in this embodiment may be CacheDel, the third annotation acts on the request instruction, and the cache corresponding to the third annotation may be deleted, and then the return value of the request instruction is obtained in the storage medium. The configuration attribute of the third annotation can be keyHeads, where keyHeads is a prefix set of keys, multiple keys can be configured, and multiple caches can be deleted to delete unnecessary data in the Redis cache and save storage space.

In some of the embodiments, when the annotation is the fourth annotation, processing the request instruction includes: obtaining the fourth annotation, and the parameter marked by the fourth annotation is used to assemble the key in the Redis cache. The fourth annotation in this embodiment may be KeyParam, and the fourth annotation acts on the parameter of the request instruction, and can set the actual parameter key. When the request command includes parameters, at least one parameter is required to configure KeyParam, keyHead can set the prefix of the request command, and the actual key will also assemble the parameter value annotated with the KeyParam. The configuration properties of KeyParam may include order, returnClassValueType and returnClassType. Among them, order is the order when the parameter value is used as the key, returnClassValueType is when the return value corresponds to the subscript of classType, when the parameter value is the value of classValueType, the return parameter is classType, and returnClassType indicates the type of the return value. Among them, returnClassValueType and returnClassType can distinguish the actual return type when the return value is the parent class.

In other embodiments, when the request instruction does not include parameters, it is not necessary to configure the KeyParam.

In some of these embodiments, the configuration parameters of the cache abstraction interface include an expiration time. In this embodiment, the expiration time of the cache abstract interface can be set in the annotation, or can be set as a default value. During the process of processing the request instruction, the expiration time can be obtained through the annotation of the request instruction. After the expiration time arrives, the expiration time cannot be Use the key-value pair corresponding to the expiration time in the cache. In this embodiment, by setting the expiration time, the cache space can be saved, and dirty data can be avoided at the same time.

In some of the embodiments, after obtaining the annotation of the request instruction through the interceptor, the method further includes: in the case that the annotation cannot match the cache abstract interface, obtaining the return value of the request instruction in the storage medium. The "annotation cannot match the cache abstract interface" specifically means that the cache abstract interface does not set a corresponding interface for the annotation. In this case, the return value of the request instruction can be directly obtained from the storage medium. The method provided by this embodiment improves the scene adaptability of the method for processing a request instruction.

It should be noted that the steps shown in the above flow or the flow chart of the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical sequence is shown in the flow chart, in the In some cases, steps shown or described may be performed in an order different from that herein.

This embodiment also provides a system for processing request instructions, and the system is used to implement the above-mentioned embodiments and preferred implementation manners, which have been described and will not be repeated. As used below, the terms "module," "unit," "subunit," etc. may be a combination of software and/or hardware that implements a predetermined function. Although the apparatus described in the following embodiments is preferably implemented in software, implementations in hardware, or a combination of software and hardware, are also possible and contemplated.

FIG. 4 is a structural block diagram of a system for processing request instructions according to an embodiment of the present application. As shown in FIG. 4 , the system includes: a cache module 41 and a core module 42; the cache module 41 receives a request instruction and obtains the request through an interceptor The annotation of the instruction; the core module 42 matches the annotation with the cache abstract interface, and obtains the processing method of the request instruction, wherein the processing method corresponds to the annotation; the cache module 41 performs the request instruction according to the processing method. processing, the core module 42 returns the return value of the request instruction.

In this embodiment, the cache module 41 identifies the annotation used by the request instruction, and can directly enter the cache database to process the request instruction. The developer does not need to manually write code, which solves the need for the developer to manually manage the cache and connect to the cache database. Cost, time-consuming and low-efficiency problems, realize the automatic management of the cache database, improve the processing efficiency of the request command, save time, and improve the consistency and standardization of the program.

The embodiments of the present application are described and illustrated below in combination with application scenarios.

FIG. 5 is a schematic structural diagram of a cache framework for request instruction processing according to an embodiment of the present application. As shown in FIG. 5 , the cache framework 51 includes a cache module 41 and a core module 42 , and the cache module 41 includes a lua script file, cache implementation, annotations , distributed lock implementation, distributed lock annotation interceptor, cache annotation interceptor, cache annotation processor and distributed lock annotation processor, the core module 42 includes configuration, cache interface, enumeration, exception, annotation return value, sequence implementations, utility classes, and serialization factories.

Among them, the lua script file in the cache module 41 is to ensure the atomicity of distributed locks when operating in the Redis cache; the cache implementation provides cache implementations in various serialization methods; annotations can be provided for developers to perform request instructions. Processing; distributed lock implementation provides distributed lock implementation in various serialization methods; Spring AOP-based interceptors intercept request instructions that use annotations, including distributed lock annotation interceptors and cache annotation interceptors; This embodiment provides a variety of serialization methods for developers to choose from, and the processor is to handle different serialization methods, including a cache annotation processor and a distributed lock processor.

Among them, the configuration in the core module 42 is used to configure the cache, such as Redis address, port, password and other configuration data; the cache interface is used to define the interface specification of the framework, which can provide a cache abstract interface and a distributed lock interface; enumeration and Exception defines an enumeration class and an exception class respectively, which can implement unified code specification, unified error code, and facilitate error checking; annotated return value is convenient for parsing the deserialized data; the creation of tool classes is convenient for code development; serialization implementation provides Multiple serialization methods, such as jdk serialization, kryo serialization and fastjson serialization, developers can call different serialization factories and use different serialization implementations according to actual needs.

This embodiment includes four cache abstract interfaces. The first cache abstract interface is used to set the value, and the cache key, cache object, expiration time, and return object can be set. The second cache abstract interface is used to set the value. The expiration time of key, cache object and return object is one month by default. The third cache abstract interface is used to obtain the value, and the cache key and return object can be set. The fourth cache abstract interface is used to delete the value, and the cache key can be set. Through the above cache abstract interface, the serialization implementation class can be used to serialize and deserialize respectively in the process of getting (get) and setting (set).

In the process of using the cache framework 51, FIG. 6 is a flowchart of request instruction processing according to a preferred embodiment of the present application. As shown in FIG. 6, the method includes the following steps:

Step S601, the annotation of the request instruction is intercepted by the interceptor of the cache module.

Step S602, the cache module judges the annotation of the request instruction, reads the key and expiration time in the configuration attribute of the annotation, and calls the cache implementation class.

Step S603, the core module invokes the serialization implementation class to set or read the return value of the request instruction.

In step S604, the core module returns the return value to the cache module, and the cache module returns the return value to the developer business item, where the developer business item is a module for the developer to connect and view various services.

Developers add cache or distributed lock annotations to the request instructions that need to use cache and distributed locks. The cache module will intercept the request instructions through AOP, and assemble the real cache key through the configured keyHead and parameter values. If there is no return value, the implementation of the original method will be called, and if there is a return value in the Redis cache, the cached return value will be returned directly without continuing to call the method implementation.

The framework provided by this embodiment can reduce the workload of developers using the cache, and only need to add annotations to the request instructions to implement the cache, and developers can focus more on business development. Further, through the framework of this embodiment, developers can also implement implementation classes based on interfaces in the framework, so the framework in this embodiment has great convenience.

It should be noted that each of the above modules may be functional modules or program modules, and may be implemented by software or hardware. For the modules implemented by hardware, the above-mentioned modules may be located in the same processor; or the above-mentioned modules may also be located in different processors in any combination.

In one embodiment, a computer device is provided, which may be a terminal. The computer equipment includes a processor, memory, a network interface, a display screen, and an input device connected by a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium, an internal memory. The nonvolatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the execution of the operating system and computer programs in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external terminal through a network connection. The computer program, when executed by a processor, implements a method of requesting instruction processing. The display screen of the computer equipment may be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer equipment may be a touch layer covered on the display screen, or a button, a trackball or a touchpad set on the shell of the computer equipment , or an external keyboard, trackpad, or mouse.

In one embodiment, FIG. 7 is a schematic diagram of the internal structure of an electronic device according to an embodiment of the present application. As shown in FIG. 7 , an electronic device is provided. The electronic device may be a server, and its internal structure diagram may be as shown in FIG. 7 . shown. The electronic device includes a processor, memory, network interface and database connected by a system bus. Among them, the processor of the electronic device is used to provide computing and control capabilities. The memory of the electronic device includes a non-volatile storage medium and an internal memory. The nonvolatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the execution of the operating system and computer programs in the non-volatile storage medium. The database of the electronic device is used to store the data. The network interface of the electronic device is used to communicate with an external terminal through a network connection. The computer program, when executed by a processor, implements a method of requesting instruction processing.

Those skilled in the art can understand that the structure shown in FIG. 7 is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the electronic device to which the solution of the present application is applied. The specific electronic device may be Include more or fewer components than shown in the figures, or combine certain components, or have a different arrangement of components.

In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and running on the processor. When the processor executes the computer program, the processor implements the request instruction processing provided by the above embodiments steps in the method.

In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored, and when the computer program is executed by a processor, implements the steps in the method for processing a request instruction provided in each of the foregoing embodiments.

Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium , when the computer program is executed, it may include the processes of the above-mentioned method embodiments. Wherein, any reference to memory, storage, database or other medium used in the various embodiments provided in this application may include non-volatile and/or volatile memory. Nonvolatile memory may include read only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous chain Road (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

The technical features of the above-described embodiments can be combined arbitrarily. For the sake of brevity, all possible combinations of the technical features in the above-described embodiments are not described. However, as long as there is no contradiction between the combinations of these technical features, All should be regarded as the scope described in this specification.

The above-mentioned embodiments only represent several embodiments of the present application, and the descriptions thereof are relatively specific and detailed, but should not be construed as a limitation on the scope of the invention patent. It should be noted that, for those skilled in the art, without departing from the concept of the present application, several modifications and improvements can be made, which all belong to the protection scope of the present application. Therefore, the scope of protection of the patent of the present application shall be subject to the appended claims.

Claims (10)

1. A method for requesting instruction processing, wherein the method comprises: Receive the request instruction, and obtain the annotation of the request instruction through the interceptor; Matching the annotation with the cache abstract interface to obtain a processing method for the request instruction, wherein the processing method corresponds to the annotation; The request instruction is processed according to the processing method, and the return value of the request instruction is returned. 2 . The method according to claim 1 , wherein, when the annotation is the first annotation, the processing of the request instruction according to the processing method comprises one of the following: In the case that the return value of the request instruction exists in the Redis cache, call the Redis cache, and obtain the return value of the request instruction in the Redis cache; In the case that the return value of the request instruction does not exist in the Redis cache, obtain the return value of the request instruction in the storage medium, set the return value to the Redis cache through serialization, and The configuration properties of the first annotation are set. 3 . The method according to claim 1 , wherein, when the annotation is a second annotation, the processing the request instruction according to the processing method comprises: 3 . Load the lua script, obtain distributed locks in the Redis cache, and the configuration attributes of the second annotation include the number of reentrant locks and the interval time; In the case that the distributed lock exists in the Redis cache, the request instruction is not processed, or, in the case that the distributed lock does not exist in the Redis cache, the request instruction is obtained from the storage medium The return value of the request instruction is requested, and the distributed lock is released. 4 . The method according to claim 1 , wherein, when the annotation is a third annotation, the processing the request instruction according to the processing method comprises: 5 . In the Redis cache, delete the key-value pair, wherein the key of the key-value pair is the key marked by the third annotation. 5 . The method according to claim 1 , wherein, when the annotation is a fourth annotation, the processing the request instruction according to the processing method further comprises: 6 . The fourth annotation is obtained, and the parameters marked by the fourth annotation are used to assemble the keys in the Redis cache. 6. The method according to claim 1, wherein the configuration parameter of the cache abstract interface includes an expiration time. 7. The method according to claim 1, characterized in that, after obtaining the annotation of the request instruction through the interceptor, the method further comprises: In the case that the annotation cannot be matched with the cache abstract interface, the return value of the request instruction is obtained in the storage medium. 8. A system for requesting instruction processing, wherein the system comprises: a cache module and a core module; The cache module receives the request instruction, and obtains the annotation of the request instruction through the interceptor; The core module matches the annotation with the cache abstract interface, and obtains a processing method for the request instruction, wherein the processing method corresponds to the annotation; The cache module processes the request instruction according to the processing method, and the core module returns a return value of the request instruction. 9. A computer device, comprising a memory, a processor and a computer program stored on the memory and running on the processor, wherein the processor implements the computer program as claimed in the claims The steps of any one of 1 to 7. 10. A computer-readable storage medium on which a computer program is stored, characterized in that, when the program is executed by a processor, the steps of the method according to any one of claims 1 to 7 are implemented.

Images