SpringBoot30 整合Mybatis-Plus、整合Redis、利用Ehcache实现二级缓存、利用SpringCache和Redis作为缓存

SpringBoot+mybatis-Plus 启动二级缓存 添加@Cacheable注解(如果同时存在多个,参数内容不能相同)添加@CacheNamespace注解。同时对象也需要进行序列化。在配置文件中开启缓存。 阅读详情

 

1 环境说明

  JDK: 1.8

  MAVEN: 3.

  SpringBoot: 2.0.4

 

2 SpringBoot集成Mybatis-Plus

  2.1 创建SpringBoot

    利用IDEA创建SpringBoot项目,引入web mysql mybatis-plus lombok devtools依赖

    技巧01:SpringBoot没有mybatis的启动依赖,需要到maven仓库查询

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.1</version>
        </dependency>

复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>spring_mybatisplus_redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring_mybatisplus_redis</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--<dependency>-->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!--<artifactId>spring-boot-starter-data-redis</artifactId>-->
        <!--</dependency>-->

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

复制代码

  2.2 配置数据库连接

    在 application.yml中配置数据库的连接信息

  2.3 创建实体类

    根据数据表创建对应的实体类

复制代码

/*
Navicat MySQL Data Transfer

Source Server         : mysql5.4
Source Server Version : 50540
Source Host           : localhost:3306
Source Database       : testdemo

Target Server Type    : MYSQL
Target Server Version : 50540
File Encoding         : 65001

Date: 2018-09-16 22:55:16
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `student`
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int(50) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `age` int(10) NOT NULL,
  `address` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8mb4;

-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('1', 'wys', '24', '重庆');
INSERT INTO `student` VALUES ('2', '王杨帅', '24', '重庆');
INSERT INTO `student` VALUES ('3', '王杨帅', '25', '渝足');
INSERT INTO `student` VALUES ('4', '王杨帅', '25', '重庆');
INSERT INTO `student` VALUES ('5', '杨玉林', '0', '大足');
INSERT INTO `student` VALUES ('6', '杨玉林', '22', '渝足');
INSERT INTO `student` VALUES ('7', '杨玉林', '20', '重庆');
INSERT INTO `student` VALUES ('8', '杨玉林', '24', '大足');
INSERT INTO `student` VALUES ('9', 'wys', '33', '渝足');
INSERT INTO `student` VALUES ('10', '杨玉林', '24', '重庆');
INSERT INTO `student` VALUES ('11', '杨玉林', '32', '渝足');
INSERT INTO `student` VALUES ('12', '杨玉林', '24', '大足');
INSERT INTO `student` VALUES ('13', '杨玉林', '6', '重庆');
INSERT INTO `student` VALUES ('14', '三少', '24', '渝足');
INSERT INTO `student` VALUES ('15', '杨玉林', '4', '大足');
INSERT INTO `student` VALUES ('16', '杨玉林', '24', '渝足');
INSERT INTO `student` VALUES ('17', 'wys', '12', '重庆');
INSERT INTO `student` VALUES ('18', '杨玉林', '0', '渝足');
INSERT INTO `student` VALUES ('19', '杨玉林', '24', null);

复制代码

  2.4 创建持久层接口

    技巧01:由于使用的是mybatis-plus,所以持久层接口只要继承了BaseMapper就可以拥有简单的CRUD功能,这一点跟SpringData JPA 很相似

  2.5 启动类配置

    在启动类上添加@MapperScan注解来扫描持久层接口,只有添加了这个注解才可以依赖注入持久层接口

  2.6 测试

    》依赖注入持久层接口

    》调用mybatis-plus默认提供的方法进行CRUD操作

 

3 SpringBoot集成Mybatis-Plus进阶

  说明:在第2节中是利用mybatis-plus提供的方法进行CRUD操作,其实mybatis-plus是对mybatis的封装,它同样可以向mybatis那样利用xml映射文件来实现数据库操作

  3.1 创建mybatis配置文件

复制代码

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印SQL语句到控制台 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
</configuration>

复制代码

  3.2 创建映射文件

    技巧01:在resources目录下创建一个xml文件用来存放映射文件

    技巧02:在映射接口中声明一个方法

复制代码

package com.example.spring_mybatisplus_redis.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.spring_mybatisplus_redis.pojo.dataobject.Student;

/**
 * @author 王杨帅
 * @create 2018-09-16 22:31
 * @desc
 **/
public interface StudentMapper extends BaseMapper<Student> {

    Student getById(Long id);

}

复制代码

复制代码

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.spring_mybatisplus_redis.mapper.StudentMapper">

    <select id="getById" resultType="Student">
        SELECT *
        FROM student
        WHERE id = #{id}
    </select>

</mapper>

复制代码

  3.3 配置文件

    在 application.yml 中配置mybatis配置文件和映射文件位置

  3.4 测试效果

 

4 MyBatis-Plus开启二级缓存

  技巧01:mybatis的以及缓存默认是开启的,二级缓存默认是关闭的

  技巧02:一级缓存是SqlSession级别,二级缓存是SqlSessionFactory级别

  技巧03:从二级换粗中获取到的数据都是缓存数据的副本,从一级缓存中获取到的数据是缓存数据的引用

  4.1 Mybatis默认的二级缓存

    技巧01:直接在映射文件中添加  <cache /> 即可开启二级缓存

    技巧02:mybatis默认的二级缓存是利用Map实现的

    4.1.1 序列化实体类

      使用二级缓存时必须对实体类进行序列化

    4.1.2 映射文件修改

      在映射文件中添加  <cache /> 

    4.1.3 利用映射器进行数据操作

      技巧01:映射器 = 映射接口 + 映射文件

      说明:本案例比较简单,直接在controller类中依赖注入映射器接口,实际开发中应该在service中进行的

    4.1.4 测试效果

      启动应用后,访问多次 /test/{id} 

      技巧01:第一次访问时会从数据库中读取数据,后面的就会从二级缓存中读取数据

      技巧02:delete、update、insert操作都会清空二级缓存,前提是这三种操作对应的标签上的 flushCache属性值为true(默认值就是true)

  4.2 利用EhCache实现二级缓存

    4.2.1 引入ehcache依赖

        <dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>1.1.0</version>
        </dependency>

    4.2.2 配置EhCache

复制代码

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd">
    <diskStore path="java.io.tmpdir/Tmp_EhCache" />
    
    <defaultCache eternal="false" maxElementsInMemory="1000"
        overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
        timeToLiveSeconds="3600" memoryStoreEvictionPolicy="LRU" />

    <cache name="content" maxEntriesLocalHeap="200"
        timeToLiveSeconds="3600">
    </cache>

</ehcache>

复制代码

    4.2.3 修改映射文件

    4.2.4 测试效果

      启动应用多次访问 /student/{id}

  4.3 利用Spring Cache实现缓存

    4.3.1 新建一个SpringBoot项目

      引入web springcache依赖

复制代码

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

复制代码

    4.3.2 开启SpringCache依赖

      在启动类上利用@EnableCaching来引入SpringCache的默认配置

    4.3.3 如何使用

      在需要使用缓存的方法上添加相关注解就可以啦,例如

  4.4.4 测试效果

    启动应用,多次访问 /test/test01 时,只打印了一次日志,因为从第二次开始就会到SpringCache中去寻找对应的缓存数据

    说明:SpringCache一般用于service层中的方法的,这里只是为了达到测试效果就直接在controller层中进行了测试

  4.4 利用Redis实现缓存

    注意使用Redis实现缓存时需要用到SpringCache相关技术,因为SrpingCache支持多种缓存实现

    SpringBoot项目集成好SpringCache和Redis后,只需要在application.yml文件中配置  spring.cache.type=redis 就可以啦

    技巧01:具体使用时在方法上添加@Cacheable等类似注解就可以啦

复制代码

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1/javaarchitect?characterEncoding=utf-8&useSSL=false
    username: root
    password: 182838

  thymeleaf:
    cache: false

  redis:
    host: 127.0.0.1
    port: 6379

  cache:
    type: redis

  jpa:
    properties:
      hibernate:
        format_sql: true
        show_sql: true

mybatis-plus:
  type-aliases-package: com.example.homework.pojo
  config-location: classpath:/mybatis-config.xml
  mapper-locations: classpath:xml/*Mapper.xml

复制代码

 

5 SpringBoot 集成 Spring Cache

  请参见第4.3小节

 

6 SpringBoot集成Redis

  6.1 安装redis服务器

    参考博文

  6.2 创建SpringBoot项目

    引入web redis lombok devtools依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

  6.3 配置redis服务信息

spring.redis.host=127.0.0.1
spring.redis.port=6379

  6.4 重写配置RedisTemplate对应Bean的配置

    主要是为了设置序列化方式

复制代码

package com.example.spring_redis02.configs;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.net.UnknownHostException;

@Configuration
public class RedisConfiguration {

    /**
     * 重写RedisTemplate的Bean
     * @param redisConnectionFactory
     * @return
     * @throws UnknownHostException
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(new ObjectMapper());

        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);

        return template;
    }

}

复制代码

  6.5 编写RedisTemplate工具类

    技巧01:这个工具类只是为了简化操作而言的,没有也没关系

复制代码

package com.example.spring_redis02.utils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================  

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key 键
     * @param by  要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key 键
     * @param by  要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================  

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //============================set=============================  

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================  

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

复制代码

  6.6 测试效果

SpringBoot+mybatis-Plus+分页+二级缓存 因为之前是这样写的@Cacheable(value = "businessList", key = "'businessList'"),这样太绝对了,于是把参数放进去,这样参数更改之后,就能够查询到不同的数据。而@CacheEvict(value = "businessList", allEntries = true)这个注解就是你对数据进行操作之后清除缓存用的。今天测试了一下,如果传参根据参数进行查询,查到的数据不变,还是之前的数据。于是就对注解的参数进行了设置。 阅读详情

相关推荐

自学ROS完成智能小车路径规划(一)--配置功能包

此系列文章记录本人学习ros的过程,将会尽可能详细以便自己能够看懂 参考系列:古月居老师,优快云,ROS tutorials,科大讯飞智能车竞赛线上赛 本文章的目标: 比较全局路径规划算法中A*算法与Dijkstra算法在该地图场景下的规划与运行时间 比较局部路径规划算法中DWA算法与TEB算法在该地图场景下的规划与运行时间 在同等参数条件下选择出各自适合的算法进行融合,经过比较,我将选择dijkstra算法作为全局路径规划算法,TEB算法为局部路径规划算法 第一步,按照科大讯飞的教程配置文件 科大讯

weixin_42621524的博客 9366

SpringBoot30 整合Mybatis-Plus、整合Redis、利用Ehcache实现二级缓存、利用SpringCache和Redis作为缓存...

1 环境说明   JDK: 1.8   MAVEN: 3.   SpringBoot: 2.0.4 2 SpringBoot集成Mybatis-Plus   2.1 创建SpringBoot     利用IDEA创建SpringBoot项目,引入web mysql mybatis-plus lombok devtools依赖     技巧01:SpringBoot没有...

weixin_30263073的博客 544

基于Python大数据的智能交通分析系统

该系统能够实时监测交通状况,分析交通流量,预测交通趋势,为交通管理部门提供决策支持,帮助缓解交通拥堵,提高交通运行效率,减少交通事故发生率,改善市民出行体验。它能够为交通管理部门提供决策支持,帮助缓解交通拥堵,提高交通运行效率,减少交通事故发生率,改善市民出行体验,促进交通产业的健康发展。数据采集层:通过传感器、GPS设备、交通摄像头等数据源,实时采集交通数据,如车辆速度、位置、道路拥堵情况等。数据分析层:运用统计学方法、机器学习算法等,对处理后的数据进行深入分析,挖掘交通规律,预测交通趋势。

qq3828614760的博客 2969

springboot-mybatisplus-redis二级缓存

springboot mybatisplus redis二级缓存

无bug无江湖 3146

从示波器波形看懂死区:手把手教你调ST MCU的PWM,避免三相桥直通炸管

本文详细解析了如何通过示波器波形判断PWM死区时间,并手把手教你调整STM32高级定时器寄存器,避免三相逆变桥直通炸管。文章涵盖死区时间的本质与风险、STM32配置详解、示波器调试技巧及FOC系统中的特殊考量,帮助工程师优化电机驱动性能与安全性。

weixin_30315723的博客 735

arcgis插件 批量出图 按地块批量出图工具(动态文本、动态节点坐标表)

arcgis插件 批量出图 按地块批量出图工具。

坐听风雨 7075

MyBaits-Plus使用redis作为缓存的另外一种方法

使用MyBatis Plus生成项目框架,使用Redis作为缓存,重新自定义了service的父类和接口.

柳老师的博客 1281

halcon3D 点云拟合球体

halon3D 点云拟合球面

weixin_43213429的博客 1641

MyBatis-Plus一级缓存和二级缓存-redis解决缓存的脏数据

一级缓存:也称为本地缓存,基于 PerpetualCache 的 HashMap 本地缓存,其存储作用域为SqlSession,用于保存用户在一次会话过程中查询的结果,用户一次会话中只能使用一个sqlSession,各个SqlSession之间的缓存相互隔离,当 Session flush 或 close 之后,该 SqlSession 中的所有 Cache 就将清空,MyBatis默认打开一级缓存、不允许关闭。MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。

tiger_Angle 4845

MATLAB 控制 E4438C 信号源的研究

通过 MATLAB,我们可以实现对 E4438C 的远程控制,从而实现更高的自动化和可编程性。总结起来,通过使用 MATLAB 和 Instrument Control Toolbox,我们可以轻松地控制 E4438C 信号源并生成各种类型的信号。需要注意的是,以上代码仅为示例,实际应用中可能需要根据具体情况进行更详细的配置和错误处理。此外,MATLAB 还提供了一系列函数和命令,可用于控制 E4438C 信号源的其他功能,如频率调谐、功率设置、调制设置等。您可以根据自己的需求进行相应的配置和控制。

RswtPerl的博客 1017

风控系统中的架构设计原型图分析与实践探讨

本文探讨了风控系统的架构设计原型图在风险管理中的重要性。通过分析多个案例,文章展示了如何利用架构设计原型图提升团队沟通效率,优化系统结构与功能。强调了良好的架构设计不仅有助于系统的可扩展性和可维护性,还能增强对风险的应对能力。最后,呼吁金融行业持续关注技术进步与市场需求变化,以不断提升风控系统的设计与实施效果。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 6万+

springboot+mybatis-plus+redis整合(附上脚手架完整代码)

首先新建一个springboot项目 next到这里的时候,我们可以选择用jdk几,还有就是group,这个一般就是com.公司名字了,artifact就是项目名字。个人开发我还是喜欢用com.名字前缀哈。 到了这一步的话,如果对这个项目有什么别的需求,比如需要用到mybatis啥的可以勾相应的选项。其实就是idea自动帮咱导入相关的依赖。这里我们暂且啥也不勾。写过这么多的项目,咱们自己整合的依赖还是挺香的哈。 2:导入依赖 可能我比较懒,喜欢用mybatisplus,这些是整合mybatisplus需要

风团团 6880

gurobi最新下载安装教程 2023.11

我下载的最新版gurobi支持python3.7-python3.11,这个序号与计算机硬件捆绑,一旦激活就会失效。运行激活码之后,产生的。如果既放置在了上面的默认搜索目录,又设置了。系统环境变量(不是用户环境变量),指向保存的目录和文件名(例如。高版本产生的许可文件兼容低版本。验证不会成功,学术许可不会激活。之后cmd进入命令行,cd进入gurobi所在的。,实测不到一小时即可审核完毕,获得对应的许可。如果学校的网关没有将本校的。系统环境变量指向不同的目录和文件,原厂无关,是学校网络的设置问题。

Cachel Wood的博客 2万+

Spring Boot + MybatisPlus开启二级缓存(注解形式)

Spring Boot + MybatisPlus开启二级缓存(注解形式)只需三步!请看下面。

qq_43813351的博客 1584

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

MyBatis二级缓存使用以及MyBatis-Plus整合(SpringBoot版)

MyBatis二级缓存

madonghyu的博客 1万+

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

Spring+MyBatisPlus+Ehcache 使用MyBatisPlus二级缓存

1、依赖及版本 &lt;!-- Mybatis Plus 核心库 mybatis通用代码生成器--&gt; &lt;dependency&gt; &lt;groupId&gt;com.baomidou&lt;/groupId&gt; &lt;artifactId&gt;mybatis-plus&lt;/artif...

weweeeeeeee的博客 3506

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

redis作为mybaits(mybatisplus)的缓存

【代码】redis作为mybaits(mybatisplus)的缓存。

HongRi_的博客 984

SpringBoot整合Mybatis-Plus 实战之Mybatis-Plus的一级缓存、二级缓存详解

前言 现在的JAVA行业,貌似已经是SpringBoot + SpringCloud 的天下了,早期的SSH,SSM框架已经老去,与SpringBoot相结合的JPA框架虽然省去了很多的增删改查sql,但是比较笨拙,在面对一些复杂多变的逻辑时常常力不从心,而相对应的Mybatis由于其高度的灵活性受到广大码农的欢迎。之前整合过了springboot+mybatis,前几天看到一个面试的问一个问题,Mybatis的一级缓存,二级缓存。我想这个应该也是一个重点吧,所以今天决定来详细解读一下神秘的一二级缓存。

爱吃早餐的程序员 1万+

springboot使用mybatis二级缓存

mybatis二级缓存,

weixin_42855525的博客 1091

第3章 SpringBoot+MyBatisPlus+Redis案例实战

分布式存储极致性能Redis6

m0_50829683的博客 972

springboot+mybatis-plus+redis整合

1、创建springboot项目 2、在pom.xml内添加依赖 <properties> <mybatis-plus.version>3.1.0</mybatis-plus.version> <redisson.version>3.10.6</redisson.version> </properties> <!-- 使用redisson集...

寻常的博客 2597

【Mybatis】Mybatis 二级缓存全详解教程

MyBatis-Plus(简称MP)是一个基于 MyBatis 的增强工具,它简化了 MyBatis 的开发,并且提供了许多便利的功能,帮助开发者更高效地进行持久层的开发。

小电玩 5782

详解SpringBoot整合Mybatis开启本地二级缓存和使用redis开启二级缓存

这就提供了可观的性能提升。二级缓存是Mapper级别的缓存,多个SqlSession去操作同一个Mapper中的sql语句,则这些SqlSession可以共享二级缓存,即二级缓存是跨SqlSession的。设置useCache=false可以禁用当前select语句的二级缓存,即每次查询都会发出sql去查询,默认情况是true,即该sql使用二级缓存。mybatis中有一级缓存和二级缓存,我们常用的是一级缓存,mybatis会默认打开。映射文件中,用相同的sql去查询数据,会去对应的二级缓存内取结果。

境里婆娑 4925

SpringBoot项目中使用缓存的正确姿势,太优雅了!

点击上方“芋道源码”,选择“设为星标”管她前浪,还是后浪?能浪的浪,才是好浪!每天 10:33更新文章,每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路,很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...

芋艿V 4702

MyBatis-Plus中用Redis作为二级缓存,对mapper层操作方法

在启用mybatis-plus时,可以通过本方法使用redis作为二级缓存

qq_51778285的博客 2481

Spring Boot+Mybatis Plus 使用Redis实现二级缓存具体步骤以及代码

以上就是使用Spring Boot+Mybatis Plus和Redis实现二级缓存的具体步骤和代码示例。在具体的业务代码中,通过在Mapper方法上添加缓存注解,即可实现自动缓存数据到Redis中。1. 首先,确保你已经添加了Spring Boot、Mybatis Plus和Redis的依赖。max-active: 最大连接数。max-idle: 最大空闲连接数。min-idle: 最小空闲连接数。max-wait: 最大等待时间。database: 数据库。password: 密码。

huanghm88的专栏 1688
上一篇: 高性能分布式锁-redisson的使用
下一篇: Redis01 Redis服务端环境搭建
It_BeeCoder
博客等级 码龄10年 967粉丝 238原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值