xmemcached数据同步

1. 解决方案描述

   通过不同模块对应不同版本号解决缓存同步问题。

2. 结构图

   

3. 代码

    CacheVersion.java缓存版本

package com.hr.util;

import java.util.HashMap;
import java.util.Map;
/**
 * 存放最新缓存版本号
 * @author Administrator
 *
 */
public class CacheVersion {
	
	private static Map<String,Object> versionMap=new HashMap<String,Object>();

	

	public static String getValue(String key){
		String str=null;
		try {
			str=versionMap.get(key).toString();
		} catch (Exception e) { 
			e.printStackTrace();
		}
		System.out.println(str);
		return str;
	}
	
	public static void setValue(String key,String value){
		versionMap.put(key, value);
	}
	
}

MemEnum.java可根据实际业务声明枚举，每一个枚举代表一个模块

package com.hr.util;

public enum MemEnum {
	position("职位"),
	company("公司、充值、消费");
	
	
	private String desc;
	
	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

	private MemEnum(String _desc){
		this.desc=_desc;
	}
}

UUIDGenerator.java 获取版本号

package com.hr.util;

import java.util.UUID;

public class UUIDGenerator { 
	
    public static String getUUID(){ 
        String s = UUID.randomUUID().toString().toUpperCase(); 
        return s.replace("-", ""); 
    } 
    public static void main(String[] args) {
		System.out.println(UUIDGenerator.getUUID());
	}
}

Test.java测试

package com.memcached.test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeoutException;

import com.danga.MemCached.SockIOPool;
import com.hr.util.CacheVersion;
import com.hr.util.MemEnum;
import com.hr.util.UUIDGenerator;

import net.rubyeye.xmemcached.GetsResponse;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;


public class Test {
	private static MemcachedClientBuilder builder = new XMemcachedClientBuilder( AddrUtil.getAddresses ("192.168.11.138:11211"));
	private static MemcachedClient mcc;
	static{
		try {
			mcc =builder.build();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) throws TimeoutException, InterruptedException, MemcachedException, IOException {
		//通过定义枚举，控制一个模块（如职位有关的）的缓存，可自定义模块大小范围
		
		//第一种情况，赋值
		setValue("k1",MemEnum.position.toString(),"数据1",100);
		Object result= getValue("k1",MemEnum.position.toString());
		System.out.println(result);
		
		setValue("k1",MemEnum.position.toString(),"数据2",100);
		result= getValue("k1",MemEnum.position.toString());
		System.out.println(result);
		//第二种情况，更新数据时,只需要更新对应模块的版本号，再次获取发现版本号不匹配，返回null
		CacheVersion.setValue(MemEnum.position.toString(), UUIDGenerator.getUUID());
		//result=null
		result= getValue("k1",MemEnum.position.toString());
		System.out.println(result);
		
	}
	/**
	 * 根据key和版本key获取value
	 * @param keyName
	 * @param versionKeyName
	 * @return
	 * @throws MemcachedException 
	 * @throws InterruptedException 
	 * @throws TimeoutException 
	 */
	private static Object getValue(String key,String versionKey ) throws TimeoutException, InterruptedException, MemcachedException{
		//先判断版本是否最新
		String version_value=mcc.get(versionKey);
		String cacheVersion=CacheVersion.getValue(versionKey);
		if(version_value!=null && cacheVersion!=null && cacheVersion.equals(version_value)){
			return mcc.get(key);
		}
		return null;	
	}
	/**
	 * 根据key和版本块设置value
	 * @param keyName
	 * @param versionKeyName
	 * @param obj
	 * @param expiry
	 * @throws TimeoutException
	 * @throws InterruptedException
	 * @throws MemcachedException
	 */
	private static void setValue(String key, String versionKey, Object value, int expiry) throws TimeoutException, InterruptedException, MemcachedException{
		String version= UUIDGenerator.getUUID();
		//设置/更新缓存
		mcc.set(key, expiry, value);
		//设置/重新设置 缓存版本号
		mcc.set(versionKey, 0, version);
		//记录最新版本号
		CacheVersion.setValue(versionKey, version);
		
	}
	
	
}