前因
處室的一個項目，會有大量的數據需要頻繁被使用（查詢），很少做新增修改刪除的操作，這種數據很適合使用Redis進行緩存，所以新的版本想把Redis引入進來。
細化
使用Redis倒是難度不大，但是怎么樣舒服的使用Redis就要多考慮一下了：
1、可以使用Jedis直接對Redis操作，這樣的好處是全部自主掌控，可以在自己需要的地方增加對Redis的操作，壞處也顯而易見，就是對現有代碼改造比較大；另外一種方法是，通過Mybatis的二級緩存實現，優點是，對現有代碼改造少，缺點也有，下面說。
2、單位對Redis的支持力度一般，不像有些公司會搭建平臺級的Redis，我們都是每個項目自己搭建自己的Redis環境。所以很多同事會對Redis的高可用性報以懷疑（主要因為不熟悉），所以要保證Redis掛了之后，系統可以照常使用（讀DB）。進而要求做一個開關，可以選擇性的使用Redis。總結，兩個問題：
1）設置開關；關閉時，不使用Redis。
2）開關打開后，系統在運行過程中，Redis掛了，系統應該照常運行。
3、領導想把Redis做成整個處室所有系統公用的，所以在Redis中的Key需要做一定的處理。
實現
吐槽一下，單位的網...連不上...github
1、pom.xml
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-redis</artifactId>
<version>1.0.0-beta2</version>
</dependency>
2、redis.properties，放到resource目錄下
redis.ip=localhost redis地址
redis.port=6379 redis端口
jedis.pool.maxActive=3000 最大連接數
jedis.pool.maxIdle=1000 空閑時最大連接數
jedis.pool.maxWait=1500 最大等待時間
jedis.pool.testOnBorrow=true
jedis.pool.testOnReturn=true
redis.switch = true 開關
redis.key = SOA redis的KEY,以這個開頭，區分系統
3、實現org.apache.ibatis.cache.Cache接口
見文章最下方
4、mybatis-config.xml開啟二級緩存
<setting name="cacheEnabled" value="true" />
5、mybatis的Mapper配置文件中增加配置：
<cache type="com.taikang.tms.cache.RedisCache" />
<select id="selectAllConfig" resultMap="dataSourceConfig" useCache="false">
select id,managecom,dataSourceName,managename from dataSourceConfig
</select>
其中useCache="false"表示，這個查詢SQL不進行緩存。
<select id="selectConfigByManagecom" resultMap="dataSourceConfig" parameterType="String" useCache="true">
select id,managecom,dataSourceName,managename from dataSourceConfig where managecom=#{managecom}
</select>
useCache="true"，這個查詢SQL的結果進行緩存。（第一個sql是查詢全部，一般這種sql我們不做緩存）
其余的insert、update、delete操作，可以進行如下配置：
flushCache="true/false"，當設置成true的時候，執行sql會把redis中的緩存刪除（調用Cache實現類的clear()方法），設置成false，則不做操作。
所以到這里也可以清楚的理解何時進行緩存、何時進行刪除緩存了：
程序剛啟動的時候，Redis中是空的。
每次執行select的時候，首先會去redis讀取，讀取不到的話，再去db中查詢，查詢結束后，將結果存入redis中，注意，如果sql查詢無結果，也會放入redis中。
執行insert、update、delete語句的時候，清除對應的redis中的值。
上面說到使用這種方式的缺點....就是...框架自動生成的key看的很不爽，比如：
-189751634:3770288340:DataSourceConfigMapper.selectConfigByManagecom:0:2147483647:select id,managecom,dataSourceName,managename from dataSourceConfig where managecom=?:C
這是一個Key，從這個也能看出來，有一部分是select的查詢語句。前面的數字看起來就不爽了，沒有翻源碼，不知道是啥含義。
這里還有一個坑需要注意，就是緩存刪除，前面說過執行mybatis配置文件中的insert、update、delete操作的時候會刪除緩存，不過有些系統....會直接登錄到數據庫上做一些操作吧，這種操作，緩存肯定是無法刪除的。
我們系統做的更簡單，因為我們系統中，這些需要緩存的數據基本上都是通過SQL語句初始化進去的，不需要前臺有維護頁面，所以...每次維護數據之和，手動去redis中進行flushdb。或者考慮啟動服務的時候刪除，或者前臺做一個按鈕什么的，點擊一下刪除redis中的緩存。
單位的網....不能連接github，今天嘗試了一下使用其他的代碼托管網站，也都失敗了，并且我沒有找到簡書上如何上傳附件，這次拼了，直接上代碼：
RedisCache.java
package com.taikang.tms.cache;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.taikang.tms.util.JedisUtils;
import com.taikang.tms.util.ConfigUtils;
public class RedisCache implements Cache {
private static Logger logger = LoggerFactory.getLogger(RedisCache.class);
private String cacheId;
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
public RedisCache(String cacheId) {
if (cacheId == null) {
throw new IllegalArgumentException("Cache instances require an ID");
}
this.cacheId = ConfigUtils.key + "." + cacheId;
logger.info("NTSRedisCache cacheId ========== " + cacheId);
if(ConfigUtils.redisSwitch){
JedisUtils.getInstance();
}
}
@Override
public String getId() {
return cacheId;
}
@Override
public void putObject(Object key, Object value) {
//TODO:開關采用一個靜態變量，每個需要使用redis的地方，都判斷這個變量，比較繁瑣
logger.info("NTSRedisCache putObject = " + cacheId);
if(ConfigUtils.redisSwitch){
JedisUtils.put(cacheId, key, value);
}
}
@Override
public Object getObject(Object key) {
logger.info("NTSRedisCache getObject = " + cacheId);
if(ConfigUtils.redisSwitch){
return JedisUtils.get(cacheId, key);
}else{
return null;
}
}
@Override
public Object removeObject(Object key) {
logger.info("NTSRedisCache removeObject = " + cacheId);
if(ConfigUtils.redisSwitch){
return JedisUtils.remove(cacheId, key);
}else{
return null;
}
}
@Override
public void clear() {
logger.info("NTSRedisCache clear = " + cacheId);
if(ConfigUtils.redisSwitch){
JedisUtils.removeAll(cacheId);
}
}
@Override
public int getSize() {
logger.info("NTSRedisCache getSize = " + cacheId);
if(ConfigUtils.redisSwitch){
return JedisUtils.getSize(cacheId);
}else{
return -1;
}
}
@Override
public ReadWriteLock getReadWriteLock() {
return readWriteLock;
}
}
所用到的幾個工具類：
ConfigUtils.java
package com.taikang.tms.util;
import java.io.IOException;
import java.util.Properties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.JedisPool;
public class ConfigUtils {
private static Logger logger = LoggerFactory.getLogger(ConfigUtils.class);
public static boolean redisSwitch ;
public static int maxIdle ;
public static boolean testOnBorrow;
public static boolean testOnReturn;
public static String ip;
public static int port;
public static String key;
public static int fail_count = 0 ;
static {
Properties props = new Properties();
try {
props.load(JedisUtils.class.getResourceAsStream("/properties/redis.properties"));
redisSwitch = Boolean.valueOf(props.getProperty("redis.switch"));
maxIdle = Integer.valueOf(props.getProperty("jedis.pool.maxIdle"));
testOnBorrow = Boolean.valueOf(props.getProperty("jedis.pool.testOnBorrow"));
testOnReturn = Boolean.valueOf(props.getProperty("jedis.pool.testOnReturn"));
ip = props.getProperty("redis.ip") ;
port = Integer.valueOf(props.getProperty("redis.port"));
key = props.getProperty("redis.key") ;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void setSwitch(boolean redisSwitch){
if(true == ConfigUtils.redisSwitch && false == redisSwitch){
//switch : open --> close
logger.info("switch : open --> close");
JedisUtils.closeJedisPool();
}else if(false == ConfigUtils.redisSwitch && true == redisSwitch){
//switch : close --> open
logger.info("switch : close --> open");
JedisUtils.getInstance();
}
ConfigUtils.redisSwitch = redisSwitch ;
}
//TODO:當redis連接異常超過一定數量之后， 不再走redis,但是沒有一個機制，當redis恢復之后會重新使用redis
public static void setFailCount(){
if(redisSwitch){
fail_count += 1;
//TODO:失敗數量配置到配置文件中
if(fail_count > 10){
logger.info(" setSwitch(false) ");
setSwitch(false);
}
}
}
public static void setSucc(){
if(fail_count > 0 ){
fail_count = 0 ;
}
if(!redisSwitch){
setSwitch(true);
}
}
}
JedisUtils.java
package com.taikang.tms.util;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
import org.mybatis.caches.redis.RedisCallback;
import org.mybatis.caches.redis.SerializeUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;
public class JedisUtils {
private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);
private static JedisPool JEDISPOOL;
public static void getInstance(){
if(JEDISPOOL == null){
logger.info(" JedisUtils getInstance ");
Properties props = new Properties();
try {
//TODO:配置文件固定，換成使用spring加載的方式
JedisPoolConfig conf = new JedisPoolConfig();
conf.setMaxIdle(ConfigUtils.maxIdle);
conf.setTestOnBorrow(ConfigUtils.testOnBorrow);
conf.setTestOnReturn(ConfigUtils.testOnReturn);
JEDISPOOL = new JedisPool(conf, ConfigUtils.ip, ConfigUtils.port);
} catch (Exception e) {
logger.error("加載[jedis.properties]異常[" + e.getMessage() + "]", e);
}
}
}
public static Jedis getJedis() {
try{
return JEDISPOOL.getResource();
}catch (Exception e) {
//throw new JedisConnectionException("Could not get a resource from the pool");
return null;
}
}
public static void recycleJedis(Jedis jedis) {
if(jedis != null){
jedis.close();
}
}
public static void closeJedisPool(){
if(JEDISPOOL != null){
JEDISPOOL.close();
}
}
/**
* Redis存儲Object序列化流
* */
public static void put(String id , Object key, Object value) {
Jedis jedis = getJedis();
try{
logger.info(" redis put ... key = [" + key + "]");
//jedis.set(SerializeUtils.serialize(key), SerializeUtils.serialize(value));
jedis.hset(id.toString().getBytes(), key.toString().getBytes(), SerializeUtils.serialize(value));
//TODO:考慮用切片處理
ConfigUtils.setSucc();
}catch(Exception e){
//TODO:異常放在utils中捕捉，還是在NTSRedisCache捕捉
//TODO:統一異常處理方法
ConfigUtils.setFailCount();
logger.error("Redis執行異常[" + e.getMessage() + "]" , e);
}finally {
recycleJedis(jedis);
}
}
public static <T> T get(String id , Object key) {
Jedis jedis = getJedis();
try{
//T value = SerializeUtils.unserialize(jedis.get(SerializeUtils.serialize(key)));
T value = SerializeUtils.unserialize(jedis.hget(id.toString().getBytes(), key.toString().getBytes()));
logger.info(" redis get ... key = [" + key + "] , value = [" + value + "]");
ConfigUtils.setSucc();
return value;
}catch(Exception e){
ConfigUtils.setFailCount();
logger.error("Redis執行異常[" + e.getMessage() + "]" , e);
}finally {
recycleJedis(jedis);
}
return null;
}
public static Long remove(String id , Object key) {
Jedis jedis = getJedis();
try{
Long num = jedis.hdel(id.toString(), key.toString());;
//Long num = jedis.del(SerializeUtils.serialize(key));
ConfigUtils.setSucc();
return num;
}catch(Exception e){
ConfigUtils.setFailCount();
logger.error("Redis執行異常[" + e.getMessage() + "]" , e);
}finally {
recycleJedis(jedis);
}
return 0L;
}
public static void removeAll(String id) {
Jedis jedis = getJedis();
try{
jedis.del(id.toString());
//jedis.flushDB();
ConfigUtils.setSucc();
}catch(Exception e){
ConfigUtils.setFailCount();
logger.error("Redis執行異常[" + e.getMessage() + "]" , e);
}finally {
recycleJedis(jedis);
}
}
public static int getSize(String id) {
return 0;
/*Jedis jedis = getJedis();
try{
Map<byte[], byte[]> result = jedis.hgetAll(id.toString().getBytes());
return result.size();
}catch(Exception e){
ConfigUtils.setFailCount();
logger.error("Redis執行異常[" + e.getMessage() + "]" , e);
}finally {
recycleJedis(jedis);
}
return -1 ;*/
}
}
SerializeUtils.java
package com.taikang.tms.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeUtils {
//private static final Logger logger = Logger.getLogger(SerializeUtils.class);
private static void close(ObjectOutputStream objectOutputStream, ByteArrayOutputStream byteArrayOutputStream) {
try {
if (byteArrayOutputStream != null) {
byteArrayOutputStream.close();
}
if (objectOutputStream != null) {
objectOutputStream.close();
}
} catch (Exception e) {
e.printStackTrace();
//logger.error("關閉IO資源異常[" + e.getMessage() + "]", e);
}
}
private static void close(ObjectInputStream objectInputStream, ByteArrayInputStream byteArrayInputStream) {
try {
if (objectInputStream != null) {
objectInputStream.close();
}
if (byteArrayInputStream != null) {
byteArrayInputStream.close();
}
} catch (Exception e) {
e.printStackTrace();
//logger.error("關閉IO資源異常[" + e.getMessage() + "]", e);
}
}
public static byte[] serialize(Object object) {
ObjectOutputStream objectOutputStream = null;
ByteArrayOutputStream byteArrayOutputStream = null;
try {
byteArrayOutputStream = new ByteArrayOutputStream();
objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(object);
byte[] bytes = byteArrayOutputStream.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace();
//logger.error("序列化對象異常[" + e.getMessage() + "]", e);
} finally {
close(objectOutputStream, byteArrayOutputStream);
}
return null;
}
@SuppressWarnings("unchecked")
public static <T> T unserialize(byte[] bytes) {
if (bytes == null)
return null;
ByteArrayInputStream byteArrayInputStream = null;
ObjectInputStream objectInputStream = null;
try {
byteArrayInputStream = new ByteArrayInputStream(bytes);
objectInputStream = new ObjectInputStream(byteArrayInputStream);
return (T) objectInputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
} finally {
close(objectInputStream, byteArrayInputStream);
}
return null;
}
}
測試用例...就不貼了，我繼續找找單位可以使用的代碼托管軟件..話說，今天連各種SVN都試過了。
