CN110109956B

CN110109956B - Method and terminal for preventing cache from penetrating

Info

Publication number: CN110109956B
Application number: CN201910215734.4A
Authority: CN
Inventors: 刘德建; 林伟; 郭玉湖
Original assignee: Fujian Tianquan Educational Technology Ltd
Current assignee: Fujian Tianquan Educational Technology Ltd
Priority date: 2019-03-21
Filing date: 2019-03-21
Publication date: 2021-10-01
Anticipated expiration: 2039-03-21
Also published as: CN110109956A

Abstract

The invention discloses a method and a terminal for preventing cache penetration, wherein keys with empty database query results are recorded in an empty value cache, the request times of each key in the empty value cache in preset time are counted, when the request times reach the preset times, the keys with the request times reaching the preset times are added to a common cache, and the method is different from the prior art of adding all empty value caches in a database to the common cache.

Description

Method and terminal for preventing cache from penetrating

Technical Field

The present invention relates to the field of cache technologies, and in particular, to a method and a terminal for preventing cache from being penetrated.

Background

The cache technology is a common means for improving the running performance of a program, a general system uses a special cache server such as redis or memcache as a cache layer, provides cache service in a cluster or single-node manner, and adds corresponding codes in a service system to support the cache service.

Generally, the interface service queries the cache in advance, queries the database if the cache does not contain data to be queried, and loads the queried data into the cache, so that data with frequent requests can be put into the cache, and the pressure of the database is relieved. But when a malicious attack occurs, all pressure can still be given to the database through cache penetration. For example, the keys currently cached are positive integers, and when a negative number is used as a key to access the cache, the cache is penetrated, the database is continuously accessed, and particularly in a high concurrency condition, great pressure is brought to the database.

The cache penetration generally has three conditions of malicious attack, first data access and empty data, wherein the malicious attack is to use a key which does not exist in the current cache to access; for the first data access, namely no data exist in the current cache, all requests access the database; the empty data, namely the data of the database, is also empty, so that the condition that the data cannot be obtained when the database is accessed is caused, and the data cannot be obtained, so that the corresponding data cannot exist in the cache, the penetration is caused, and the pressure is brought to the database.

Disclosure of Invention

The technical problem to be solved by the invention is as follows: the method and the terminal for preventing the cache from penetrating are provided, the cache can be dynamically controlled, and the cache from penetrating is effectively prevented.

In order to solve the technical problems, the invention adopts a technical scheme that:

a method of preventing cache breakthrough, comprising the steps of:

s1, recording the key with the database query result being empty to an empty value buffer;

s2, counting the request times of each key in the null value buffer within the preset time, judging whether the request times reach the preset times, and if so, adding the keys of which the request times reach the preset times to a common buffer.

In order to solve the technical problem, the invention adopts another technical scheme as follows:

a terminal for preventing cache breakthrough, comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, the processor implementing the following steps when executing the computer program:

The invention has the beneficial effects that: the method comprises the steps of recording empty keys in a database query result to an empty value buffer, counting the number of times of requests of each key in the empty value buffer within preset time, and adding the keys with the number of times of requests reaching the preset number to a common buffer when the number of times of requests in the empty value buffer reaches the preset number, wherein the method is different from the prior art of adding all empty value buffers in the database to the common buffer.

Drawings

FIG. 1 is a flowchart illustrating steps of a method for preventing cache snooping according to an embodiment of the present invention;

fig. 2 is a schematic structural diagram of a terminal for preventing cache breakthrough according to an embodiment of the present invention;

FIG. 3 is a diagram illustrating relationships among modules in a method for preventing cache breakthrough according to an embodiment of the present invention;

FIG. 4 is a diagram illustrating relationships among modules in a method for preventing cache breakthrough according to an embodiment of the present invention;

description of reference numerals:

1. a terminal for preventing cache breakthrough; 2. a memory; 3. a processor.

Detailed Description

In order to explain technical contents, achieved objects, and effects of the present invention in detail, the following description is made with reference to the accompanying drawings in combination with the embodiments.

The key concept of the invention is that the key with empty database query result is recorded to an empty value buffer, if the number of times of requests in the empty value buffer reaches the preset number of times of keys in the preset time, the number of times of requests reaches the preset number of times of keys is added to a common buffer.

Referring to fig. 1, a method for preventing cache breakthrough includes the steps of:

From the above description, the beneficial effects of the present invention are: the method comprises the steps of recording empty keys in a database query result to an empty value buffer, counting the number of times of requests of each key in the empty value buffer within preset time, and adding the keys with the number of times of requests reaching the preset number to a common buffer when the number of times of requests in the empty value buffer reaches the preset number, wherein the method is different from the prior art of adding all empty value buffers in the database to the common buffer.

Further, the step S1 includes, before the step,:

receiving a data request, wherein the data request comprises a key corresponding to data;

accessing the common cache according to the key, if the query result of the common cache is null, querying the database, judging whether the query result of the database is null, if so, querying the null cache, and executing S1; if not, adding the data corresponding to the key to a common buffer;

the step S1 includes:

judging whether data corresponding to a key with an empty database query result can be queried in an empty value buffer, if not, adding the key to the empty value buffer, and recording the number of requests corresponding to the key, wherein the initial value of the number of requests is 1; and if so, adding 1 to the numerical value of the request times corresponding to the key.

According to the above description, the null value cache in the database is dynamically controlled by the control cache, and the null value cache processing and the common cache are separately arranged without affecting the original logic, so that the counting of the null value cache key is realized, whether the null value cache key is added to the common cache or not is conveniently judged subsequently, a large amount of cache penetration services in a high concurrency scene are effectively prevented, and the stability of the database is maintained.

Further, setting corresponding expiration time for each key in the null value buffer;

in step S2, the step of counting the number of times of requests of each key in the null value buffer within a preset time specifically includes:

counting the number of times of requests of each key in the null value buffer before the corresponding expiration time;

the step S2 further includes:

and judging whether the key corresponding to the expiration time in the null value buffer is expired or not according to the expiration time, and if so, automatically deleting the data corresponding to the expired key.

According to the description, the expired keys can be automatically cleared in time by setting the expiration time of each key in the null value buffer and automatically deleting the keys when the keys expire, so that a large number of key values are prevented from occupying null value buffer resources.

Further, before adding the key whose number of requests reaches the preset number to the normal buffer in step S2, the method further includes:

and calling a local cache adding interface provided by each application, and adding the key with the request times reaching the preset times to a local memory through the local cache adding interface.

As can be seen from the above description, by adding the key whose number of times of request reaches the preset number to the local memory in advance, the corresponding null cache can be read from the local memory when querying the null cache, and compared with reading the corresponding null cache from the general cache, the local memory can respond to the data information more quickly without performance loss, and realize faster data response without affecting the original service logic.

Further, a switch mark is arranged in the local memory;

the step of receiving the data request and accessing the common buffer according to the key further comprises the following steps:

judging whether to access a local memory according to the switch mark, and if not, accessing a common cache according to the key; and if the key is found, inquiring a local memory according to the key, and if the data corresponding to the key is not inquired in the local memory, accessing the common buffer according to the key.

As can be seen from the above description, by setting the switch flag, when the switch flag is turned on to access the local memory, the local memory is accessed in advance to perform an inquiry, and when the switch flag is turned off to access the local memory, the common cache is accessed according to the original logic, so that whether the local memory is accessed or not can be controlled conveniently, and convenience is improved.

Referring to fig. 2, a terminal for preventing cache breakthrough includes a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor executes the computer program to implement the following steps:

Further, the step S1 includes, before the step,:

the step S1 includes:

the step S2 further includes:

Further, a switch mark is arranged in the local memory;

Example one

Referring to fig. 1 and 3, a method for preventing cache breakthrough includes the steps of:

an interface API receives a data request sent by a client, wherein the data request comprises a key corresponding to data;

the interface API accesses the common cache according to the key, and if the query result of the common cache is an empty string, the query result is directly returned to the client; if the query result of the common buffer is null, querying the database, judging whether the query result of the database is null, if so, indicating that no relevant data information is found, querying the null buffer, and executing S1; if not, adding the data corresponding to the key to a common buffer;

the empty string refers to that data is inquired according to the key, but the data is the empty string; the null value is that data is not inquired according to the key;

the common buffer is a main buffer;

specifically, whether data corresponding to a key with an empty database query result can be queried in an empty value buffer is judged, if not, the key is added to the empty value buffer, and a request number value corresponding to the key is recorded, wherein an initial value of the request number value is 1, and the request number value is also stored in the empty value buffer; if yes, the key is stored in the null value buffer, and the value of the request times value corresponding to the key is added with 1;

the key with the database query result being empty is the empty value cache key;

as shown in fig. 3, when the empty buffer needs to be accessed, the modules through which the whole process flows are a client, an interface API, a common buffer, a database and an empty buffer;

Wherein, preferably, the preset times are 30 times;

for example, a certain key in the null value buffer is requested 30 times within a preset time, and a null value is returned every time the database is queried, at this time, the value of the number of times of request value of the key in the null value buffer is 30, and the key is added to the common buffer when the preset number of times is reached;

when the data request with the key is received next time, the interface API only needs to inquire and return in the common buffer, and a database does not need to be inquired.

Example two

The difference between this embodiment and the first embodiment is:

setting corresponding expiration time for each key in the null value buffer;

the expiration time can be set according to a specific service scenario, and preferably, the expiration time corresponding to each key in the null value buffer is consistent with the expiration time of each key in the database;

for example, the expiration time is 1 minute, a certain key in the null value buffer is requested 30 times within 1 minute, and a null value is returned every time the database is queried, at this time, the value of the number of times the key is requested in the null value buffer is 30, and the key is added to the normal buffer when the preset number is reached;

the step S2 further includes:

EXAMPLE III

Referring to fig. 4, the difference between the present embodiment and the first or second embodiment is:

before adding the key whose number of requests reaches the preset number to the normal buffer in the step S2, the method further includes:

calling a local cache adding interface provided by each application, wherein the local cache adding interface is used for adding null value cache keys to a local memory;

adding the key with the request times reaching the preset times to a local memory through the local cache adding interface;

as shown in fig. 4, the null value cache further performs an operation of adding a null value cache key to the local memory;

a switch mark is arranged in the local memory, and the switch mark can be represented by a boolean parameter, for example, 1 represents that local memory access is started, and 0 represents that local memory access is closed;

the failure time of the switch mark is consistent with the failure time of the key, namely the failure time of the key in the database is consistent with the expiration time of the key in the database;

Example four

Referring to fig. 2, a terminal 1 for preventing cache breakthrough includes a memory 2, a processor 3, and a computer program stored on the memory 2 and executable on the processor 3, where the processor 3 implements the steps in the first embodiment when executing the computer program.

EXAMPLE five

Referring to fig. 2, a terminal 1 for preventing cache breakthrough includes a memory 2, a processor 3, and a computer program stored in the memory 2 and running on the processor 3, wherein the processor 3 implements the steps of the second embodiment when executing the computer program.

EXAMPLE six

Referring to fig. 2, a terminal 1 for preventing cache breakthrough includes a memory 2, a processor 3, and a computer program stored in the memory 2 and running on the processor 3, wherein the processor 3 implements the steps of the third embodiment when executing the computer program.

In summary, the method and the terminal for preventing cache penetration provided by the present invention record the key with empty database query result into the empty value buffer, set the corresponding expiration time for each key in the empty value buffer, count the number of requests of each key in the empty value buffer within the expiration time, add the key with the number of requests reaching the preset number to the local memory and the normal buffer when the key with the number of requests reaching the preset number occurs in the empty value buffer, query the local memory in advance when the data request of the key is received next time, access the normal buffer for query when the query result of the local memory is empty, different from the prior art of adding all empty value buffers in the database to the normal buffer, the present invention sets the empty value buffer to dynamically control the empty value buffers, and realize mutual independence with the normal buffer, the expired keys can be automatically cleaned in time, empty value buffer resources are prevented from being occupied by a large number of key values, meanwhile, only the empty value buffer keys with the request times exceeding the preset times are added to the common buffer, the number of the empty value buffer keys in the common buffer is reduced, the local memory is inquired in advance, faster data response can be achieved under the condition that the original service logic is not influenced, and the problem of buffer penetration in a high-concurrency scene is effectively prevented.

The above description is only an embodiment of the present invention, and not intended to limit the scope of the present invention, and all equivalent changes made by using the contents of the present specification and the drawings, or applied directly or indirectly to the related technical fields, are included in the scope of the present invention.

Claims

1. A method for preventing cache breakthrough, comprising the steps of:

s2, counting the request times of each key in the null value buffer within a preset time, judging whether the request times reach the preset times, and if so, adding the keys of which the request times reach the preset times to a common buffer;

2. The method for preventing cache penetration according to claim 1, wherein the step S1 is preceded by:

the step S1 includes:

3. The method according to claim 1, further comprising setting an expiration time for each key in the null value buffer;

the step S2 further includes:

4. The method according to claim 2, wherein a switch flag is set in the local memory;

5. A terminal for preventing cache breakthrough, comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the processor implements the following steps when executing the computer program:

6. The terminal for preventing cache penetration according to claim 5, wherein the step S1 is preceded by:

the step S1 includes:

7. The terminal of claim 5, further comprising setting an expiration time for each key in the null value buffer;

the step S2 further includes:

8. The terminal for preventing cache penetration according to claim 6, wherein a switch flag is set in the local memory;