mybatis通过配置文件方式整合redis缓存，替换mybatis二级缓存

最新推荐文章于 2023-09-30 00:15:00 发布
置顶 最新推荐文章于 2023-09-30 00:15:00 发布
阅读量5.5k 收藏 10
点赞数 4
文章标签： mybatis redis 缓存 java 二级缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjl33/article/details/50401211
版权

mybatis通过redis取代二级缓存，二级缓存的缺点不再赘述。

mybatis默认缓存是PerpetualCache，可以查看一下它的源码，发现其是Cache接口的实现；那么我们的缓存只要实现该接口即可。

该接口有以下方法需要实现：

  String getId();
  int getSize();
  void putObject(Object key, Object value);
  Object getObject(Object key);
  Object removeObject(Object key);
  void clear();
  ReadWriteLock getReadWriteLock();

下面开始实现代码

==============================华丽的分割线========================

1，RedisCache实现类

import org.apache.ibatis.cache.Cache;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * Cache adapter for Redis.
 *
 * @author Eduardo Macarron
 */
public final class RedisCache implements Cache {

  private static JedisPool pool;

  private final ReadWriteLock readWriteLock = new DummyReadWriteLock();
  private final String id;

  private final Integer expireSeconds;

  public RedisCache(final String id) {
    if (id == null) {
      throw new IllegalArgumentException("Cache instances require an ID");
    }
    this.id = id;
    final RedisConfig redisConfig = RedisConfigurationBuilder.getInstance().parseConfiguration();
    pool = new JedisPool(redisConfig, redisConfig.getHost(), redisConfig.getPort(), redisConfig.getConnectionTimeout(),
        redisConfig.getSoTimeout(), redisConfig.getPassword(), redisConfig.getDatabase(), redisConfig.getClientName());

    expireSeconds = redisConfig.getSettings().get(id) * 60;
  }

  @Override
  public void clear() {
    execute(new RedisCallback() {
      @Override
      public Object doWithRedis(Jedis jedis) {
        // jedis.del(id.toString());

        throw new UnsupportedOperationException("not support redis-cache getsize method.");
        // return null;
      }
    });

  }

  private Object execute(RedisCallback callback) {
    final Jedis jedis = pool.getResource();
    try {
      return callback.doWithRedis(jedis);
    } finally {
      jedis.close();
    }
  }

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

  @Override
  public Object getObject(final Object key) {
    return execute(new RedisCallback() {
      @Override
      public Object doWithRedis(Jedis jedis) {
        // return SerializeUtil.unserialize(jedis.hget(id.toString().getBytes(),
        // key.toString().getBytes()));
        return SerializeUtil.unserialize(jedis.get(key.toString().getBytes()));
      }
    });
  }

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

  @Override
  public int getSize() {
    return (Integer) execute(new RedisCallback() {
      @Override
      public Object doWithRedis(Jedis jedis) {
        throw new UnsupportedOperationException("not support redis-cache getsize method.");
      }
    });
  }

  @Override
  public void putObject(final Object key, final Object value) {
    execute(new RedisCallback() {
      @Override
      public Object doWithRedis(Jedis jedis) {
        System.out.println("缓存----------------:" + key);
        jedis.set(key.toString().getBytes(), SerializeUtil.serialize(value));
        if (expireSeconds > 0) {
          jedis.expire(key.toString().getBytes(), expireSeconds);
        }
        // jedis.hset(id.toString().getBytes(), key.toString().getBytes(),
        // SerializeUtil.serialize(value));
        return null;
      }
    });
  }

  @Override
  public Object removeObject(final Object key) {
    return execute(new RedisCallback() {
      @Override
      public Object doWithRedis(Jedis jedis) {
        // return jedis.hdel(id.toString(), key.toString());
        // return jedis.del(key.toString());

        throw new UnsupportedOperationException("not support redis-cache getsize method.");
      }
    });
  }

  @Override
  public String toString() {
    return "Redis {" + id + "}";
  }

}
2， DummyReadWriteLock  类 

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;

/**
 * @author Iwao AVE!
 */
class DummyReadWriteLock implements ReadWriteLock {

  static class DummyLock implements Lock {

    @Override
    public void lock() {
      // Not implemented
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
      // Not implemented
    }

    @Override
    public Condition newCondition() {
      return null;
    }

    @Override
    public boolean tryLock() {
      return true;
    }

    @Override
    public boolean tryLock(long paramLong, TimeUnit paramTimeUnit) throws InterruptedException {
      return true;
    }

    @Override
    public void unlock() {
      // Not implemented
    }
  }

  private final Lock lock = new DummyLock();

  @Override
  public Lock readLock() {
    return lock;
  }

  @Override
  public Lock writeLock() {
    return lock;
  }

}
3，RedisCallback 接口 

import redis.clients.jedis.Jedis;

public interface RedisCallback {

  Object doWithRedis(Jedis jedis);
}

4，RedisConfig 类 

import java.util.Hashtable;

import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Protocol;

public class RedisConfig extends JedisPoolConfig {

  private String host = Protocol.DEFAULT_HOST;
  private int port = Protocol.DEFAULT_PORT;
  private int connectionTimeout = Protocol.DEFAULT_TIMEOUT;
  private int soTimeout = Protocol.DEFAULT_TIMEOUT;
  private String password;
  private int database = Protocol.DEFAULT_DATABASE;
  private String clientName;

  private final Hashtable<String, Integer> settings = new Hashtable<String, Integer>();

  public String getClientName() {
    return clientName;
  }

  public int getConnectionTimeout() {
    return connectionTimeout;
  }

  public int getDatabase() {
    return database;
  }

  public String getHost() {
    return host;
  }

  public String getPassword() {
    return password;
  }

  public int getPort() {
    return port;
  }

  public Hashtable<String, Integer> getSettings() {
    return settings;
  }

  public int getSoTimeout() {
    return soTimeout;
  }

  public void setClientName(String clientName) {
    if ("".equals(clientName)) {
      clientName = null;
    }
    this.clientName = clientName;
  }

  public void setConnectionTimeout(int connectionTimeout) {
    this.connectionTimeout = connectionTimeout;
  }

  public void setDatabase(int database) {
    this.database = database;
  }

  public void setHost(String host) {
    if (host == null || "".equals(host)) {
      host = Protocol.DEFAULT_HOST;
    }
    this.host = host;
  }

  public void setPassword(String password) {
    if ("".equals(password)) {
      password = null;
    }
    this.password = password;
  }

  public void setPort(int port) {
    this.port = port;
  }

  public void setSoTimeout(int soTimeout) {
    this.soTimeout = soTimeout;
  }

}
5，RedisConfigurationBuilder 类 

import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Properties;

import org.apache.ibatis.cache.CacheException;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;

/**
 * Converter from the Config to a proper {@link RedisConfig}.
 *
 * @author Eduardo Macarron
 */
final class RedisConfigurationBuilder {

  /**
   * This class instance.
   */
  private static final RedisConfigurationBuilder INSTANCE = new RedisConfigurationBuilder();

  private static final String SYSTEM_PROPERTY_REDIS_PROPERTIES_FILENAME = "redis.properties.filename";

  private static final String REDIS_RESOURCE = "redis.properties";

  /**
   * Return this class instance.
   *
   * @return this class instance.
   */
  public static RedisConfigurationBuilder getInstance() {
    return INSTANCE;
  }

  private final String redisPropertiesFilename;

  /**
   * Hidden constructor, this class can't be instantiated.
   */
  private RedisConfigurationBuilder() {
    redisPropertiesFilename = System.getProperty(SYSTEM_PROPERTY_REDIS_PROPERTIES_FILENAME, REDIS_RESOURCE);
  }

  private boolean isInteger(String s) {
    return isInteger(s, 10);
  }

  private boolean isInteger(String s, int radix) {
    if (s.isEmpty()) {
      return false;
    }
    for (int i = 0; i < s.length(); i++) {
      if (i == 0 && s.charAt(i) == '-') {
        if (s.length() == 1) {
          return false;
        } else {
          continue;
        }
      }
      if (Character.digit(s.charAt(i), radix) < 0) {
        return false;
      }
    }
    return true;
  }

  /**
   * Parses the Config and builds a new {@link RedisConfig}.
   *
   * @return the converted {@link RedisConfig}.
   */
  public RedisConfig parseConfiguration() {
    return parseConfiguration(getClass().getClassLoader());
  }

  /**
   * Parses the Config and builds a new {@link RedisConfig}.
   *
   * @param the
   *          {@link ClassLoader} used to load the {@code memcached.properties}
   *          file in classpath.
   * @return the converted {@link RedisConfig}.
   */
  public RedisConfig parseConfiguration(ClassLoader classLoader) {
    final Properties config = new Properties();

    final InputStream input = classLoader.getResourceAsStream(redisPropertiesFilename);
    if (input != null) {
      try {
        config.load(input);
      } catch (final IOException e) {
        throw new RuntimeException("An error occurred while reading classpath property '" + redisPropertiesFilename
            + "', see nested exceptions", e);
      } finally {
        try {
          input.close();
        } catch (final IOException e) {
          // close quietly
        }
      }
    }

    final RedisConfig jedisConfig = new RedisConfig();
    jedisConfig.setHost("localhost");
    setConfigProperties(config, jedisConfig);
    return jedisConfig;
  }

  private void setConfigProperties(Properties properties, RedisConfig jedisConfig) {
    if (properties != null) {
      final MetaObject metaCache = SystemMetaObject.forObject(jedisConfig);
      for (final Map.Entry<Object, Object> entry : properties.entrySet()) {
        final String name = (String) entry.getKey();
        final String value = (String) entry.getValue();
        if (metaCache.hasSetter(name)) {
          final Class<?> type = metaCache.getSetterType(name);
          if (String.class == type) {
            metaCache.setValue(name, value);
          } else if (int.class == type || Integer.class == type) {
            metaCache.setValue(name, Integer.valueOf(value));
          } else if (long.class == type || Long.class == type) {
            metaCache.setValue(name, Long.valueOf(value));
          } else if (short.class == type || Short.class == type) {
            metaCache.setValue(name, Short.valueOf(value));
          } else if (byte.class == type || Byte.class == type) {
            metaCache.setValue(name, Byte.valueOf(value));
          } else if (float.class == type || Float.class == type) {
            metaCache.setValue(name, Float.valueOf(value));
          } else if (boolean.class == type || Boolean.class == type) {
            metaCache.setValue(name, Boolean.valueOf(value));
          } else if (double.class == type || Double.class == type) {
            metaCache.setValue(name, Double.valueOf(value));
          } else {
            throw new CacheException("Unsupported property type: '" + name + "' of type " + type);
          }
        } else if (isInteger(value)) {
          jedisConfig.getSettings().put(name, Integer.parseInt(value));
        }
      }
    }
  }
}
6，SerializeUtil 类 

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.apache.ibatis.cache.CacheException;

public final class SerializeUtil {

  public static byte[] serialize(Object object) {
    ObjectOutputStream oos = null;
    ByteArrayOutputStream baos = null;
    try {
      baos = new ByteArrayOutputStream();
      oos = new ObjectOutputStream(baos);
      oos.writeObject(object);
      final byte[] bytes = baos.toByteArray();
      return bytes;
    } catch (final Exception e) {
      throw new CacheException(e);
    }
  }

  public static Object unserialize(byte[] bytes) {
    if (bytes == null) {
      return null;
    }
    ByteArrayInputStream bais = null;
    try {
      bais = new ByteArrayInputStream(bytes);
      final ObjectInputStream ois = new ObjectInputStream(bais);
      return ois.readObject();
    } catch (final Exception e) {
      throw new CacheException(e);
    }
  }

}
7，配置文件（此处需要Goods实体，不再赘述），配置文件中缓存可以开关，如果某个select不需要缓存，则加上 useCache="false" 属性，默认不写的话值是true 

<?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.yjl.service.dao.GoodsDao">
	<cache type="com.yjl.framework.caching.mybatis.RedisCache" />
	<resultMap id="BaseResultMap" type="com.yjl.bean.Goods">
		<id column="goods_id" property="goodsId" jdbcType="INTEGER" />
		<result column="center_goods_id" property="centerGoodsId"
			jdbcType="INTEGER" />
		<result column="store_id" property="storeId" jdbcType="INTEGER" />
		<result column="brand_id" property="brandId" jdbcType="INTEGER" />
	</resultMap>
<select id="getGoodsById" resultMap="goodsDetail" parameterType="java.lang.Integer">
select goods_id,center_goods_id,store_id,brand_id from goods where goods_id = #{goodsId,jdbcType=INTEGER} limit 1
</select>
</mapper>

8,redis.properties（此处可以根据具体的namespace设置相应的缓存时间） 

host=localhost
port=6379
connectionTimeout=5000
soTimeout=4000
password=
database=0
com.yjl.service.dao.MealDao=5
com.yjl.service.dao.GoodsDao=10

代码部分已经完成，下面开始测试是否缓存

===========================华丽的分割线===========================

下面开始测试

可以看出只有第一次会查询数据库，在redis缓存时间之内不会在查询数据库


以上是本人实际工作中总结，如有错误请大家指正，欢迎大家积极评论。

yjl33
关注
详解Spring boot使用Redis集群替换mybatis二级缓存
08-30
本篇文章主要介绍了详解Spring boot使用Redis集群替换mybatis二级缓存，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Mybatis使用Redis替代二级缓存
弱水三千、先干为敬
09-18 2787
1、案例介绍 将Mybatis查询数据库的结果，以键值对的形式存入Redis数据库，替代了Mybatis中的二级缓存。查询同样操作时，可以直接去Redis中读取结果，提高效率。 2、案例实现 2.1 导入项目依赖 <!--redis依赖--> <dependency> <groupId>redis.clients</groupId&gt...
Mybatis缓存实现原理
大唐雨夜的博客
03-28 1816
Mybatis缓存 mybatis提供了对缓存的支持，分为一级缓存和二级缓存，可以通过下图来理解： ①、一级缓存是SqlSession级别的缓存，默认开启。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。 ②、二级缓存是mapper级别的缓存，基于mapper文件的namespace，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。 一级缓存 ⼀级缓存到底是什么？⼀级缓存什么时候被创建
ReadWriteLock函数进行读写锁操作
qq_41644707的博客
07-14 188
读写互斥是指当一个线程获取写锁时，其他线程不能获取任何读锁或写锁。同样，当一个线程获取读锁时，不能获取写锁。它有两个锁，分别为读锁和写锁。当一个线程获取读锁后，其他线程也可以获取读锁。但是，当一个线程获得写锁时，其他线程不能获取任何读锁或写锁。ReadWriteLock是Java并发包中的一个接口，用于提供读写锁的机制，解决多线程并发读写操作时可能出现的线程安全问题。与单一的锁不同，在读写操作之间使用不同的锁，ReadWriteLock提供了更高的并发性能和可伸缩性。
【Redis】-替代Mybatis二级缓存
HuaJi250的博客
10-31 559
文章目录1、二级缓存1.1、cache使用1.2、原理2、Redis替代二级缓存2.1、获取ApplicationContext2.2、自定义cache实现类2.3、关联查询的缓存处理3、缓存优化策略3.1、对key进行优化 1、二级缓存 作缓存的对象类型需要实现序列化 1.1、cache使用 在dao层对应的mapper配置文件中使用cache标签即可开启二级缓存 <cache/> 缓存是key-value形式，key可以看作select语句（key还包含其他信息’） 开启后，查询语句首
mybatis plus使用redis作为二级缓存的方法
08-25
首先，需要在配置文件中开启 MyBatis Plus 的二级缓存功能，可以在 application.properties 文件中添加以下配置： ```properties mybatis-plus.configuration.cache-enabled=true ``` 2. 定义 RedisTemplate 的 ...
从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与redis整合示例
01-02
mybatis与redis的简单整合示例，供大家学习参考，内含完整maven工程。 博客内容地址：https://blog.csdn.net/magi1201/article/details/85635878
myBatis整合redis
javahhhhhh的博客
12-09 1900
redis分布式缓存，mybatis提供了一个针对cache接口的redis实现类，该类存在mybatis-redis包 中 pom文件 <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-redis</artifactId> <version>1.0.0-beta2</version> </dependency> 2
Mybatis的二级缓存 (Redis方式)
Tomorrow
11-20 542
mybatis二级缓存整合redis
Mybatis集成ehcache+redis
weixin_43710113的博客
09-25 636
Mybatis集成ehcache 为什么需要缓存 拉高程序的性能 什么样的数据需要缓存 很少被修改或根本不改的数据 业务场景比如：耗时较高的统计分析sql、电话账单查询sql等 ehcache是什么 Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大 注1：本章介绍的是2.X版本，3.x的版本和2.x的版本API差异比较大 ehcache的特点 4....
MyBatis系列：缓存
牛觅成长
03-13 129
MyBatis提供了一级缓存和二级缓存，其中一级缓存基于SqlSession实现，而二级缓存基于Mapper实现。
Mybatis整合Redis实现二级缓存
m0_70274796的博客
05-03 2403
mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存 开启mybatis的二级缓存 <!--设置mybaits对缓存的支持-->    <property name="configurationProperties">        <props&g...
springboot+mybatis-plus+redis整合（附上脚手架完整代码）
风团团
09-23 5755
首先新建一个springboot项目 next到这里的时候，我们可以选择用jdk几，还有就是group，这个一般就是com.公司名字了，artifact就是项目名字。个人开发我还是喜欢用com.名字前缀哈。 到了这一步的话，如果对这个项目有什么别的需求，比如需要用到mybatis啥的可以勾相应的选项。其实就是idea自动帮咱导入相关的依赖。这里我们暂且啥也不勾。写过这么多的项目，咱们自己整合的依赖还是挺香的哈。 2：导入依赖 可能我比较懒，喜欢用mybatisplus，这些是整合mybatisplus需要
Redis与Mybatis
最新发布
qq_65052774的博客
09-30 481
在 MyBatis 的 Mapper XML 文件中使用标签和属性时，这是在告诉 MyBatis 使用默认的缓存实现。机制当 MyBatis 初始化时，它会读取 Mapper XML 文件，并根据 XML 文件内容创建相应的 Mapper 对象。当 MyBatis 遇到<cache>标签时，它会尝试实例化指定类型（type属性）的缓存对象。指定的缓存类（在本例中是）会被实例化，并且在需要缓存操作时被 MyBatis 调用。当执行查询（如）时，MyBatis 会首先检查缓存是否已经包含该查询的结果。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值