使用redis开启Mybatis的二级缓存

最新推荐文章于 2024-05-06 23:31:17 发布
最新推荐文章于 2024-05-06 23:31:17 发布
阅读量268 收藏
点赞数
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asymuxue/article/details/104925925
版权
本文介绍了在分布式系统中如何利用Redis作为二级缓存来解决Mybatis二级缓存的问题。通过引入Jedis或Lettuce连接池，配置Redis参数，获取SpringBoot工厂后门，自定义缓存机制，并在配置文件中启用二级缓存，实现了Redis与Mybatis的集成。
摘要由CSDN通过智能技术生成

概述

使用MyBatis自身的设置开启二级缓存，在分布式系统下将不起作用，因此，我们才用中间件开启二级缓存，此文介绍了使用Redis开启二级的解决策略。本文介绍了2种使用redis的开启二级缓存的机制，使用Jedis 和 lettuce。

第一种策略 使用：Jedis

Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接

①引入依赖

 <!--redis的启动器-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <version>2.1.5.RELEASE</version>
    </dependency>

②配置redis参数

在application.yml文件中添加：

#设置redis的参数
spring:
#  redis: #单机模式
#    host: 192.168.*.*
#    port: 6379
	redis: #集群模式
	    cluster:
	      nodes: 192.168.8.18:7004,192.168.8:7001,192.168.8:7002

③获取SprnigBoot工厂后门

定义一个web触发器，作用是获得整个工厂内容，方便非工厂管理的普通类，可以拿到工厂管理的对象(全局容器)
我们这么做，是为了获取 被工厂管理的redisTemplate对象。

package com.baizhi.cache;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

//web触发器，作用是获得整个工厂内容，方便非工厂管理的普通类。可以拿到工厂管理的对象(全局容器)
@Component
public class WebWare implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    //通过属性名获取对象的方法
   public static Object getbyName(String name){
       Object bean = applicationContext.getBean(name);
       return bean;
   }

   //通过属性类获取对象的方法
    public static Object getByClass(Class clazz){
        Object bean = applicationContext.getBean(clazz);
        return bean;
    }
}

④自定义缓存机制

Mybatis的cache，给需要集成其它Cache或者自定义Cache提供了接口。

package com.baizhi.cache;

import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.concurrent.locks.ReadWriteLock;
//定义自己的一个缓存策略
public class MyCache implements Cache {

    //获取工厂管理的redisTemplate对象
   private RedisTemplate redisTemplate = (RedisTemplate) WebWare.getbyName("redisTemplate");


    private String id;

    public MyCache(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void putObject(Object o, Object o1) {

        redisTemplate.opsForHash().put(id,o,o1);
    }

    @Override
    public Object getObject(Object o) {

        Object o1 = redisTemplate.opsForHash().get(id, o);
        return o1;

    }

    @Override
    public Object removeObject(Object o) {
        return null;
    }

    //清空缓存
    @Override
    public void clear() {

        redisTemplate.delete(id);
    }

    @Override
    public int getSize() {
        return 0;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return null;
    }
}

⑤启用二级缓存

在*mapper.xml文件中添加以下内容：

<cache type="com.baizhi.cache.MyCache"></cache>

第二种策略 使用 Lettuce

Lettuce的连接是基于Netty的，连接实例可以在多个线程间并发访问，并且是线程安全的，所以一个连接实例就可以满足多线程环境下的并发访问

①引入依赖

	<!--集成Redis二级缓存-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
	<!--使用连接池技术-->        
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

②配置redis参数

 #连接redis
  redis:
    host: hbase
    port: 6379
    timeout: 5s #超时时间
    lettuce:
      pool:
        max-active: 10 #最大活动数
        max-idle: 8 #最大闲置数
        max-wait: 5ms #最大等待数
        min-idle: 1 #最小闲置数
      shutdown-timeout: 100ms #超时停机时间

③在入口类中注册组件

package com.baizhi;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.web.client.RestTemplate;

import java.net.UnknownHostException;

@SpringBootApplication
@MapperScan("com.baizhi.dao")
public class UsermodelApplication {

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

    //注册一个Rest组件 SpringMVC中自带的一个Rest客户端工具，可以无缝和SpringBoot集成
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

    //注册一个Redis池技术的组件 Lettuce
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(LettuceConnectionFactory connectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //设置Key、value的序列化
        redisTemplate.setKeySerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        return redisTemplate;
    }
    
}

④获取工厂后门

package com.baizhi.cache;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class WebWare implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    //通过属性名获取对象的方法
    public static Object getbyName(String name){
        Object bean = applicationContext.getBean(name);
        return bean;
    }

    //通过属性类获取对象的方法
    public static Object getByClass(Class clazz){
        Object bean = applicationContext.getBean(clazz);
        return bean;
    }
}

⑤自定义缓存机制

package com.baizhi.cache;

import org.apache.ibatis.cache.Cache;
import org.aspectj.weaver.ast.Var;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyCache implements Cache {

    private Logger logger= LoggerFactory.getLogger(MyCache.class);
    //获取RedisTemple 对象
    //获取工厂管理的redisTemplate对象
    private RedisTemplate redisTemplate = (RedisTemplate) WebWare.getbyName("redisTemplate");
    //创建一个读写锁
    private  ReadWriteLock lock =  new ReentrantReadWriteLock();
    //设置一个超时配置
    private long timeout=300;

    //id 用于存放namespace
    private  String id;

    //提供一个构造
    public MyCache(String id) {
        this.id = id;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override // o 某一方法的唯一标识 o1 方法的返回值
    public void putObject(Object o, Object o1) {
       /* redisTemplate.opsForHash().put(id,o,o1);*/
        logger.debug("将查询结果存储到cache.key:"+o+",value:"+o1);
        ValueOperations opsForValue = redisTemplate.opsForValue();
        opsForValue.set(o,o1,timeout, TimeUnit.SECONDS);
    }

    @Override
    public Object getObject(Object o) {
        /*return redisTemplate.opsForHash().get(id,o);*/
        logger.debug("从缓存中读取结果.key:"+o);
        ValueOperations opsForValue = redisTemplate.opsForValue();
        return opsForValue.get(o);
    }

    @Override
    public Object removeObject(Object o) {
        logger.debug("从缓存中清除.key:"+o);
        ValueOperations opsForValue = redisTemplate.opsForValue();
        Object value = opsForValue.get(o);
        redisTemplate.delete(o);
        return value;
    }

    @Override
    public void clear() {
        //清除
      /*  redisTemplate.delete(id);*/
        logger.debug("从缓存中清除缓存区所有数据");
        redisTemplate.execute((RedisConnection connection) ->{
            connection.flushAll();
            return null;
        });
    }

    @Override
    public int getSize() {
        return 0;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return lock;
    }
}

⑥启用二级缓存

 <!--开启二级缓存-->
    <cache type="com.baizhi.cache.MyCache">
        <!--设置超时时间-->
        <property name="timeout" value="60"/>
    </cache>

☆Memcache 作二级缓存

https://www.cnblogs.com/brian-csyy/p/7611895.html

纯净天空7
关注
专栏目录
SpringBoot系列之使用Redis做Mybatis二级缓存
Nicky's blog
01-04 1万+
mybatis的二级缓存默认保存在内存，通过CacheNamespace指定缓存类，可以实现基于redis的缓存，implementation 属性：默认是PerpetualCache类，即hashMap实现
mybatis+redis实现二级缓存
05-24
本项目是基于maven.且需要本地安装了redis之后才能使用，因为项目里面不仅集成了redis，而且里面还集成了shiro。这是从我自己的eclipse中直接copy出来的。实测可用
springBoot 开启Redis二级缓存
weixin_39831786的博客
01-16 375
@RestController @RequestMapping("/redis") public class RedisController { /** *cacheNames 相当于一个文件夹 *key 注意 key里边一定要加一个单引号 不加就会报错 * 还要注意实体对象一定要实现序列化接口 * @return * @throw...
Redis实现Mybatis的二级缓存
王鹏的博客
02-07 832
一、Mybatis的缓存 通大多数ORM层框架一样，Mybatis自然也提供了对一级缓存和二级缓存的支持。一下是一级缓存和二级缓存的作用于和定义。    1、一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象，在对象中有一个(内存区域)数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。
Guava、Redis实现二级缓存
yangchenhui666的博客
10-08 2682
最近在重构老服务，在公共配置服务当中，博主自己设计了一个二级缓存的简易框架，支持一级缓存及二级缓存的技术替换，例如将Guava换成Caffeine，或者将Redis换成Memcached。 缓存是服务端提高接口访问速度和减轻数据库压力的利器，对于热点数据的缓存是很有必要的。 缓存也有分类： 本地缓存：Guava，Caffeine，Ehcache或者自己简单的使用HashMap实现； 分布式缓存：Redis，Memcached等。 虽然分布式缓存（redis等）单节点QPS已经到达10W级别，但是相对
【ebean】开启二级缓存 - Redis
一只文森特
01-19 391
ebean开启二级缓存
从0到1项目搭建-集成 Redis 配置MyBatis二级缓存
10-01
基于 SpringBoot 从0搭建一个企业级开发项目，基于SpringBoot 的项目，并集成MyBatis-Plus、Redis、Druid、Logback ，并使用 Redis 配置 MyBatis 二级缓存。
SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法
08-28
SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法 本文主要讲解了在SpringBoot+Mybatis项目中使用Redis实现Mybatis的二级缓存的方法。该方法可以提高查询速度，进而改善用户体验。 首先，在pom.xml文件...
mybatis plus使用redis作为二级缓存的方法
08-25
MyBatis Plus 使用 Redis 作为二级缓存的方法 MyBatis Plus 是一个基于 MyBatis 的增强工具，提供了许多实用的功能，其中之一就是支持使用 Redis 作为二级缓存。本文将详细介绍如何使用 MyBatis Plus 将 Redis 作为...
基于redis的二级缓存
08-11
NULL 博文链接：https://lpyyn.iteye.com/blog/2231048
Redis用作二级缓存
06-04
这个主要是用作在Mybatis中的Mapping文件中的二级缓存
spring-ehcache-redis两级缓存
11-13
两级缓存在redis的方案上做一步优化，在缓存到远程redis的同时，缓存一份到本地进程ehcache（此处的ehcache不用做集群，避免组播带来的开销），取缓存的时候会先取本地，没有会向redis请求，这样会减少应用服务器<–>缓存服务器redis之间的网络开销。（见下图，为了减少get这几条网络传输，我们会在每个应用服务器上增加本地的ehcache缓存作为二级缓存，即第一次get到的数据存入ehcache，后面output输出即可从本地ehcache中获取，不用再访问redis了，所以就减少了以后get的网络开销。get开销只要一次，后续不需要了，除非本地缓存过期需要再get。）
分布式系统架构——使用Redis做MyBatis的二级缓存 - CSDN博客1
08-03
1. BaseCache ：为缓存数据最终存储的处类，默认为 PerpetualCache，基于Map存储 2. EvictionCache ：当缓存数达到一定
Redis 作为二级缓存
weixin_38215806的博客
12-01 3321
这也是最近用到Redis做二级缓存，然后找文档，最后整理出来的。本人测试，是通过的状态，如果您有更好的建议或者方法。大家可以一起交流。 简介 Redis 是完全开源免费的，遵守BSD协议，是一个高性能的Key-Value 数据库。 Redis 与其他 key - value 缓存产品有以下三个特点： 1、Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。 2、Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据
Redis之二级缓存（基于Maven Web项目java实现）
最新发布
2302_78041486的博客
05-06 2374
Cacheable配置在方法或类上，作用：本方法执行后，先去缓存看有没有数据，如果没有，从数据库中查找出来，给缓存中存一份，返回结果，本次方法执行，在缓存未过期情况下，先在缓存中查找，有的话直接返回，没有的话从数据库查找。文中第一步，不需要配置，需要在spring.xml文件中配置多配置文件.properties文件引入方式： 代码在1.4.1中。@CachePut类似于更新操作，即每次不管缓存中有没有结果，都从数据库查找结果，并将结果更新到缓存，并返回结果。2.1、解注1.4中5、6、7步的代码。
第十三篇
zch001104的博客
11-13 220
首页新闻博问专区闪存云上钜惠                          我
基于redis的二级缓存机制
wqy123123wqy的博客
07-25 1964
https://github.com/Lovelcp/spring-boot-mybatis-with-redis/tree/master
SSM整合Redis实现Mybatis二级缓存
在SSM框架中整合Redis和MyBatis二级缓存，首先需要理解MyBatis的二级缓存机制。MyBatis的二级缓存是基于全局的，它可以缓存同一个namespace下的所有SQL查询结果，从而避免重复查询数据库。当执行`select`语句时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值