spring-boot+mybatis+redis整合-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_39165135/article/details/92391390

1.docker 环境下进行下载

//搜索
docker search redis

1.
docker run -d -p 6379:6379 -it --name="myredis" redis  
2.
docker run --name redis4 -p 6379:6379  -d redis:4.0.14 --requirepass "123456"


--name  将容器命名为 redis
-p   将 redis 的 6379 端口映射为宿主机器的 6379 端口
-d   指定 redis:4.0.14 镜像
--requirepass  为 redis 设定认证密码  123456



docker   ps

//查看当前的打开服务

docker exec -it myredis redis-cli
//进入redis

创建完成后

进行项目整合：

2.在项目的pom.xml文件中加入：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
//只添加上面这一个依赖，如果项目最后报红，再考虑添加下面的。
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.5</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.5</version>
        </dependency>

在spring-boot的application.properties文件中进行配置

具体如下：

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=

# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=1
#spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.jedis.timeout=0

3.在项目的config目录下创建RedisConfig.java

具体代码：


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheManager rcm = RedisCacheManager.create(connectionFactory);

        return rcm;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //序列化设置 ，这样计算是正常显示的数据，也能正常存储和获取
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        return redisTemplate;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;

    }
}

4.在主启动程序中添加注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableCaching
@EnableScheduling
@SpringBootApplication
public class EjApplication {

    public static void main(String[] args) {
        SpringApplication.run(EjApplication.class, args);
    }

}

5.在项目运用注解进行数据的抓取：

注解的解释：

看大佬的解释：https://blog.youkuaiyun.com/qq_22200097/article/details/82747149

必须要指导的是：我下面的value的值返回的是一个对象，而在这之前你的要用到的bean层对象必须要实现一个接口

Serializable:

我的注解在dao层做一个简单的测试：


@CacheConfig(cacheNames = "customer")
public interface CustomerMapper {

    @CacheEvict(value="Customer", allEntries=true)
    int deleteByPrimaryKey(Long id)throws  Exception;

    @Cacheable(value="Customer", key="#p0")
    Customer selectByPrimaryKey(Long id);

    @CachePut(key = "#p0")
    Customer findUserByNameAndPwd(@Param("realname")String username,@Param("password")String password);

（因为我的项目是前后端分离，所以可以在swagger中进行测试，如果不是前后端分离就可以直接进行前端页面输入参数进行测试。）

6.在Swagger下进行简单的操作。