redis value为对象的排序、分页的一种实现

最新推荐文章于 2024-04-17 07:09:09 发布

cristim33

最新推荐文章于 2024-04-17 07:09:09 发布

阅读量4.7k

点赞数

分类专栏： nosql hbase

本文链接：https://blog.csdn.net/cuirong1986/article/details/8240470

版权

nosql 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

hbase

3 篇文章 0 订阅

订阅专栏

-------基于HBase存储引擎并实现了排序、分页的Redis缓存策略

思路：

1、当前系统缓存json，根据key存取value，key 和value都是String类型，直接返回前端。

2、考虑支持分页，想到了缓存排好序的ResultSet，每一次前端请求，将所有数据缓存到redis，根据filter返回某页的数据，此部分数据是封装好的json。

考虑到使用list会增加开发的工作量，所以暂不用。

3、考虑缓存ResultSet对象，所以该类要实现序列化，用hadoop的Writable，不用java本身的Serializable。

4、前端需求不需要分页的仍然用原来接口，缓存json，用不同的annotation设置到查询方法上区分。

注：ResultSet为自己实现了的将hbase列存储数据转为按关系数据库行存储的数据结构。

具体实现：

1、由于每次都传给前端少量数据，所以要传给前端总记录条数方便其确定分页信息，可封转在json里。

2、rediscache操作类增加支持序列化的存取方法：

@Override
	public ResultSet getResultSetCache(String key) {
		try {
			log.info("get object from redisCache :"+key);
			ShardedJedis jedis = pool.getResource();
			ResultSet value = SerializableUtils.deSerialize(jedis.get(key.getBytes()), ResultSet.class);
			pool.returnResource(jedis);
			return value;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public boolean setResultSetCache(String key, ResultSet value) {
		try {
			log.info("add object to redisCache :"+key);
			ShardedJedis jedis = pool.getResource();
			jedis.set(key.getBytes(),SerializableUtils.serialize(value));
			pool.returnResource(jedis);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

其中SerializableUtils工具类实现对writable子类的序列化、反序列化操作：

public class SerializableUtils {

	public static<T extends Writable> byte[] serialize(Object value) throws IOException {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();

		DataOutputStream oos = new DataOutputStream(bos);
		if (value instanceof Writable) {
			((T) value).write(oos);
		} else {
			throw new IOException("not instanceof Writable!");
		}
		return bos.toByteArray();
	}

	public static <T extends Writable> T deSerialize(byte[] byteCode,Class<T> classType) throws IOException{
		ByteArrayInputStream bis = new ByteArrayInputStream(byteCode);
		T object = null;
		try {
			DataInputStream dis = new DataInputStream(bis);
			object = (T)classType.newInstance();
			object.readFields(dis);
			return object;
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}

		return null;
	}

}

java本身的序列化反序列化工具类：

public class SerializableUtil {
	
    public static<T extends Serializable> byte[] serialize(Object value){
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        
        try {
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(value);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bos.toByteArray();
    }
    
    public static <T extends Serializable> T deSerialize(byte[] bytes){
        ByteArrayInputStream bIs = new ByteArrayInputStream(bytes);
        try {
            ObjectInputStream oIs = new ObjectInputStream(bIs);
            return (T)oIs.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

3、增加两个annotation及两个切面处理类，annotation用以在具体查询方法上添加，区分需不需要排序，需要排序的缓存ResultSet，不需要的缓存Json。

需要分页的切面类主要代码：

String md5key = MD5Util.getMD5(filter.getValue().toString());
			Object value = redisCacheManager.getResultSetCache(md5key);
			String srcClzzName = "";
			boolean flag = false;
			if (null != value) {
				srcClzzName = pjp.getTarget().getClass().getSimpleName();
				JSONObject json = redisCacheManager.getJson(value,filter,srcClzzName);
				return json;
			} else if ("null".equals(value)) {
				return null;
			} else { //执行hbase查询

				ResultSet orderRs = redisCacheManager.getResultSet(filter,srcClzzName);
				boolean ifNeedCache = orderRs.size()>0?true:false;
				if (ifNeedCache == true){
					redisCacheManager.setResultSetCache(md5key, orderRs);
				}
				return redisCacheManager.getJson(orderRs, filter, srcClzzName);
			}

getResultSet部分代码：

public ResultSet getOrderdResultSet(QueryFilter filter) {
		
		SaleDetailsFilter Salefilter = (SaleDetailsFilter) filter;
		String shopId = Salefilter.getShopId();
		String date = Salefilter.getDate();// 
		int proType = Salefilter.getProType();// 
		byte sku = 1, spu = 0;
		byte isSKU = Salefilter.getIsMergeSKU() ? spu : sku;
		long[] proNum = Salefilter.getProNums();// 
		String[] itemNums = Salefilter.getItemNums();// 
		ResultSet result = new ResultSet();

		try {
			// set start row;
			ByteBuffer rowkey = ByteBuffer.allocate(13);
			rowkey.putInt(Integer.parseInt(shopId));
			rowkey.putInt(Integer.parseInt(date));
			// set product type, default 0
			rowkey.putInt(proType);
			rowkey.put(isSKU);
			byte[] endkey = CommonUtil.getEndKey(rowkey.array(),"int,int,int,byte");
			
			Where where = null;
			List<OrderBy> orderlist = null;
			
			if ((proNum != null && proNum.length > 0)) {根据前端传入的商品id查询记录
				//拼where条件
				
				for (int i = 0; i < proNum.length; i++) {
					if(i>0){
						where = or(eq("d:ProID",proNum[i]),where);
						continue;
					}
					where = eq("d:ProID",proNum[i]);
				}
				orderlist = new ArrayList<OrderBy>();
				Map<String,Integer> ordermap = Salefilter.getOrderBy();
				if(null!=ordermap){
					Set<String> keys = ordermap.keySet();
					for(Iterator<String> it = keys.iterator();it.hasNext();){
						String key = it.next();
						Integer value = ordermap.get(key);
						if(value==0){
							orderlist.add(asc(key));
						}else if(value==1){
							orderlist.add(desc(key));
						}
					}
					result = client.simpleQuery(rowkey.array(),endkey, select, tableName, where, orderlist,-1);
				}else{
					result = client.simpleQuery(rowkey.array(),endkey, select, tableName, where, null,-1);
				}
				return result;
			} else if (itemNums != null && itemNums.length > 0) {
				
				.....			} else {
				......			}
					
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		} catch (Throwable e) {
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		}
		return null;
	}

当然，用到的很多方法在cp基础上自定义的对hbase的查询接口。

4、查询接口类增加相应属性、方法，并且hbase表要加入coprocessor的支持，因为用到了聚合查询。

从缓存得到某一页的数据返回前端：

public JSONObject getPagedJson(Object value, QueryFilter filter,String srcClzzName) throws JSONException {
		
		JSONObject result = new JSONObject();
		ResultSet tempRs = (ResultSet) value;
		long size = tempRs.size();
		ResultSet realRs = new ResultSet();

		SaleDetailsFilter sdf = (SaleDetailsFilter) filter;
		int pageNum = sdf.getPageNum();
		int start = (pageNum - 1) * PAGE;
		int maxend = PAGE * pageNum-1;
		long end = size-(PAGE*pageNum)>=0?maxend:start+size-(pageNum-1)*PAGE-1;
		for (int i = start; i <= end; i++) {
			realRs.add(tempRs.get(i));
		}
		JSONObject temp = new JSONObject();
		if (realRs.size() > 0) {
			temp = trans.toJSONObject(realRs,select);
		}
		result.put(Transformer.DTL, temp);
		result.put(Transformer.SIZE, size);
		return result;
	}

5、查询接口类对应的filter增加两个属性，orderby和pageNum。Orderby表示排序的列，map类型，key表示列，值为0或1，表示升序或降序，默认为空，表示不排序。PageNum表示页号，默认第一页。