spring-boot+mybatis+redis整合

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.csdn.net/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下进行简单的操作。

7.测试结果，可以命中redis缓存。

后期可以把得到的数据变位json格式。

下面是redis的集中数据类型帮助了解redis：

redis简单命令具体操作

​                             ​

注意

​                             ​

 

​                             ​redis

默认类型都是string类型

默认有16个数据库

用select  index 来切换

index是下标，最高位15代表第16个数据库

​                             ​

​                             ​ 

 

incr:increament 增长

对key进行累加1操作，默认累加

可以针对新key或则已有的key进行操作。

类型必须是整形

应用场景：设置访问网页量

decr：减减操作，于incr一样

list表

​                             ​

 

 

list是一个双向链表，通过push，pop操作可以从链表的头部或则尾部添加删除元素，这使得list既可以用作栈，也可以作为队列。

 

​                             ​

 

上进上出是：栈

上进下出是：队列

​                             ​

 

set集合类型：

redis 的set是string类型的无序集合

​                             ​

​                             ​

​                             ​

对两个集合取交集取并集。

​                             ​

两个集合互取差集，结果是无序的，且前后元素不同时结果不同。

​                             ​

一些基本命令操作

​                             ​

 

sort set

​                             ​

​                             ​

 

​                           ​

给集合每增加一个元素，就把权值最低的元素删除。

​                             ​

​                             ​

关于重复元素：

set类型：没有

list链表类型：有

sort 类型：没有

 

Hash数据类型

（不是很重要，简单尝试）

​                             ​

 

redis的快照持久化功能（snap  shotting）

​                             ​

快照持久化是默认开启的，快照持久化所生成的文件：

​                             ​

​                             ​

可以在redis,conf中进行配置。

。。。。