Redis存储对象

2019独角兽企业重金招聘Python工程师标准>>>

      redis已经应用相当广泛了，但redis本身并没有直接存储对象的方法，我们可以通过转换对象的方式来存储对象。

大致总结了以下几种方案来存储对象：

方案一：序列化对象为二进制

使用redis的接口：

jedis.get(byte[] key)
jedis.set(byte[] key, byte[] value)

至于序列化方式，我们有很多种选择，比如：Java serialize,Protobuf,或者自己手动序列化都行

public byte[] serialize(Object obj);
public Object unSerialize(byte[] bytes);

方案二：序列化对象为字符串

使用redis的接口：

jedis.get(String key);
jedis.set(String key, String value);

序列化为字符串，我们也有很多选择：Json(Jackson,FastJson),Xml等方式

方案三：转换对象为Map

使用redis的接口：

jedis.hgetAll(String key);
jedis.hmset(String key, Map<String,String> values);

将对象转成一个map：

/**
	 * 将指定的对象数据封装成map
	 * 
	 * @param bean
	 *            对象数据
	 * @return
	 */
	@SuppressWarnings("all")
	public static Map<String, String> warp(AbstractRedisBean bean) {
		Map<String, String> propertyMap = new HashMap<String, String>();
		try {
			PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass())
					.getPropertyDescriptors();
			for (PropertyDescriptor propertyDescriptor : ps) {
				String propertyName = propertyDescriptor.getName();
				if (propertyName != null && !propertyName.equals(CLASS)) {
					Method getter = propertyDescriptor.getReadMethod();
					if (getter != null) {
						RedisBeanField mannota = getter
								.getAnnotation(RedisBeanField.class);
						if (mannota != null && mannota.serialize() == false) {
							continue;
						}
						propertyMap.put(propertyName,
								String.valueOf(getter.invoke(bean, null)));
					}
				}
			}
		} catch (Exception e) {
			logger.error(e);
		}
		return propertyMap;
	}

将map转成java对象：

/**
	 * 将map转成指定的对象
	 * 
	 * @param beanMap
	 *            map数据
	 * @param clazz
	 *            指定的类对象
	 * @return
	 */
	public static <T extends AbstractRedisBean> T reverse(
			Map<String, String> beanMap, Class<T> clazz) {
		T bean = getRedisBean(clazz);
		try {
			PropertyDescriptor[] ps = Introspector.getBeanInfo(clazz)
					.getPropertyDescriptors();
			for (PropertyDescriptor propertyDescriptor : ps) {
				String propertyName = propertyDescriptor.getName();
				if (propertyName != null && !propertyName.equals(CLASS)) {
					Method setter = propertyDescriptor.getWriteMethod();
					String value = beanMap.get(propertyName);
					String type = propertyDescriptor.getPropertyType()
							.getName();
					if (setter != null && value != null
							&& !value.equalsIgnoreCase("null")) {
						Object obj = value(value, type);
						if (obj != null) {
							setter.invoke(bean, obj);
						}
					}
				}
			}
		} catch (Exception e) {
			logger.error(e);
			e.printStackTrace();
		}
		bean.clearChangeMap();
		return bean;
	}

	/**
	 * 将String类型数值转换成指定的类型
	 * 
	 * @param value
	 *            数值
	 * @param type
	 *            指定的类型
	 * @return
	 */
	private static Object value(String value, String type) {
		if (type.equals("boolean")) {
			return Boolean.valueOf(value);
		} else if (type.equals("byte")) {
			return Byte.valueOf(value);
		} else if (type.equals("short")) {
			return Short.valueOf(value);
		} else if (type.equals("float")) {
			return Float.valueOf(value);
		} else if (type.equals("int")) {
			return Integer.valueOf(value);
		} else if (type.equals("java.lang.String")) {
			return value;
		} else if (type.equals("long")) {
			return Long.valueOf(value);
		}
		return null;
	}

这种方式有一个优势：在更新对象的时候不需要更新整个对象，只需要更新需要的字段。

总结：大致总结了三种方案，每种方式都有自己的优势和劣势，根据不同的需求进行选择。

个人博客：http://codingo.xyz

转载于:https://my.oschina.net/OutOfMemory/blog/727422