Springboot cache redis integration method

The default is to use ConcurrentMapCache of ConcurrentMapCacheManager as the cache component.

When using ConcurrentMap, the data is saved in ConcurrentMap<object></object>.

In fact, during the development process, we often use some caching middleware.

For example, we often use redis, memcache, including the ehcache we use, etc. We all use some caching middleware.

When we explained the principle before, we also discovered that springboot supports many cache configurations:

As shown in the figure below:

The default starting configuration is: SimpleCacheConfiguration.

When are other caches enabled?

We can search for these configuration classes with ctrl n, and then go in and see their conditional conditions:

## These all mean that these configurations will only take effect when you import the corresponding package.

Integrating redis as a cache

If there are students who do not know the technology of redis, there is an explanation video of the redis series released by teacher Zhou Yang in Shang Silicon Valley. Or you can visit the official website of redis as quickly as possible to learn. redis.cn is the Chinese website for redis learning.

Install redis

Search for redis image

This is connected to a foreign warehouse, and the speed is relatively slow.

We recommend using docker China.

##docker pull registry.docker-cn.com/library/redis

Start the redis image

docker run -d -p 6379:6379 --name myredis [REPOSITORY]
docker ps

For testing, open the redis connection tool.

redis desktop manager

##Test redis common data operations

#redis Operation list

##set operation of redis

Introducing the redis starter

Configuring redis

## Let’s briefly talk about the principle of redis

We After the redis starter is introduced, redisAutoConfiguration comes into play.

This RedisAutoConfiguration adds two components to the container:

The components added to the container, one One is called RedisTemplate, and the other is called StringRedisTemplate, two things.

These two things are used to operate redis.

This is the same as the jdbcTemplate that everyone used before, used to operate the database.

These are the two templates that spring uses to simplify the operation of redis. If you want to use these two things in the program, just inject them automatically.

redis test

##redis operation list:

##redis test save object

## These incomprehensible things, all They are all the results of serialization.

redisTemplate default serialization rules

Default serializer , which is the JdkSerializationRedisSerializer used.

The default serializer is the JDK serializer used.

Let’s switch to the json serializer and that’s it.

redis configuration

In the test class, our own configured redisTemplate is automatically injected.

Then we test saving the object again.

This shows that our serializer modification was successful.

This makes it clear that if we want to save the object later, we often need to modify the serializer.

Test cache

We used ConCurrentMap's cache manager before.
This cache manager helps us create cache components.
The cache component actually performs CRUD work in the cache.

Now that we have introduced redis, what will happen?
We still set debug=true in application.properties so that the automatic configuration report can be turned on.
At this time, we restart our program and search in the console.
See which automatic configuration class is effective?

The original default enabled is: SimpleCacheConfiguration.

Now that we have introduced redis-related starters, the program starts RedisCacheConfiguration by default.

Just start the program and test it directly.

It means that when you query for the first time, you query the database.

When querying for the second time, there was no output from the console, indicating that the cache was queried.

The cache is only enabled by redis by default.

Then it must be in redis.

We can check it out:

This illustrates a problem. When k and v are both objects, serialization is used to save the object by default. To save. We want redis to automatically save it as json.

What should we do?

Let’s first analyze the principles of these processes.

1. We have introduced the starter of redis, so our cachemanager has become rediscachemanager.

2. The rediscachemanager created by default passes in a redistemplate when operating our data. s things.

#3. This redistemplate was created for us by redisautoconfiguration. The default serialization mechanism used by this redistemplate is jdkserializationredisserializer. This is equivalent to the fact that the redisCacheManager that redis prevents us by default does not quite meet our requirements.

What should we do?

We should customize CacheManager.

Customized redisCacheManager

At this time, we start the project again to test. At this time, we can see the results in redis, which is We wanted it.

During Yunqiu’s next interview, she can ask those who want to come to the software park, do you know that when redis starter saves objects, redisTemplate What are the default serialization rules?

If we want to modify the default serialization rules when using redis, what should we do?

We can customize redisCacheManager, then customize redisTemplate, and pass in the json-related serializer in redisTemplate.

Small remaining problems

Database

We put a piece of data in the department table in the database:

mapper

We write a mapper corresponding to the department operation.

service

Let’s write a corresponding service

controller

Start the project test

Then let’s see if there is data in redis?

We have seen that there is dept-related data in redis.

When we query dept for the second time, we should cache redis.

But when we checked for the second time, the following error occurred.

Error

The error reported above means that json cannot be read.

Because it is necessary to convert the department's json object into the employee's json object, which is not possible.

This is because the redisCacheManager we placed is for operating employees.

So, the effect we see now is very magical.

The cached data can be stored in redis.

But when we query from the cache for the second time, we cannot deserialize it back.

It turns out that what we store is dept's json data, and our cachemanager uses the employee's template to operate redis by default.

This thing can only deserialize employee data.

Solution to the error

At this time, there are two redisCacheManagers. Which one should we use?

We can specify it in the service.

Then we restart the project, and the result is an error:

If , if we have multiple cacheManagers, we must use a certain cacheManager as our default configured cache manager.

For example, we can perform the following operations to fix the content of this startup error:

Restart for project testing

At this time, let’s see if we can deserialize and read our department information from redis normally and successfully when we perform the second department query?

At this time, we discovered that whether it is an employee or a department, we can successfully deserialize and query it from redis .

This is perfect.

Coding method to operate the cache

What we said earlier is all using annotations to place data in the cache.

However, during development, we often encounter such situations.

That is, when our development reaches a certain stage, we need to put some data into the cache.

We need to use coding to operate the cache.

For example, after we query the department information, we want to put this information into redis.

We can inject the department’s cacheManager.

Then during the coding process, we can obtain the cache by operating this cacheManager,

Then, we can operate the cache component to increase the data. Delete, modify and check.

We tested the above code and started the project, and found that it was ok and successfully put data into redis:

The above is the detailed content of Springboot cache redis integration method. For more information, please follow other related articles on the PHP Chinese website!