怎么在redis里面优雅的存一个对象？

1. 直接String梭哈。

这样带来的问题就是牵一发，动全身。假如我只想修改age字段，我需要把整个json串读出来，然后反序列化，然后修改，然后再序列化塞回去，这样实在不优雅！。

1. 字段打散

这样确实可以灵活地修改任意字段，但是会占用大量的空间。因为redis里面的一个key和一个value都是redisObject，redisObject会携带很多元信息（详细参见redis底层数据结构）。如果key过多，这些元信息占用的空间太多了！

1. Hash存储

这样就既做到了可以灵活修改任意字段，也做到了占用空间小，但是代码编写起来较为复杂。所以本文就是来解决这个问题。

快速入门

准备要你crud的类

@KeyPrefix("user")
public class User {
    @Identity
    private Long id;
    @StoreFiled("name")
    private String name;
    @StoreFiled("sex")
    private String sex;
    // 冗余信息不需要存到redis中
    @StoreFiled(ignore = true)
    private String nickName;
}

说明：

1. @KeyPrefix("user")，指定存储的key前缀，如果没有该注解，那么key前缀默认取类名小写，即 user
2. @Identity，标识该条数据的标识字段，如果 User.id = 3 ，那么他形成的redis的key就是 user:3
3. @StoreFiled("name")，标识该字段序列化到redis中，hash的field是啥，如果没有添加注解，那么没有指定@StoreFiled注解，那么field默认就是类的field名字。 如果你设置@StoreFiled(ignore = true)，那么就是希望某字段不会被序列化到Redis中。

举个例子

@KeyPrefix("user")
public class User {
    @Identity
    private Long id; // id = 5
    @StoreFiled("name")
    private String name; // name = 'qyh'
    @StoreFiled("sex") 
    private String sex; // sex = '男'
    // 冗余信息不需要存到redis中
    @StoreFiled(ignore = true)
    private String nickName; // nickName = 'qiuyuanhai'
}

调用 HashCommandOperator.uspert(Obj t)

public void testUpsert() {
    User user = new User();
    user.setId(5L);
    user.setName("qyh");
    user.setSex("男");
    user.setNickName("qiuyuanhai");
    HashCommandOperator.upsert(user);
}

存储到redis的最终模样

为什么没有字段 nickName，因为指定了 @StoreField(ignore=true)，那么它自然而然的被过滤掉了

如果你想查询该条记录，你只需要

public void testQuery() {
        User user = HashCommandOperator.query(User.class, 5L);
}

是不是超级简单？

假如你需要修改 一些字段

public void testUpsert() {
    User user = new User();
    // id必须设置
    user.setId(5L);
    // 我想要修改name字段！
    user.setName("qyhnew");
    boolean result = HashCommandOperator.upsert(user);
}

他就会变成

是不是超级简单？注意你不想修改的字段不要设置任何值！，其中id是必须设置的，upsertapi 的设计是遵循标准upser逻辑的！

假如我想删除呢？

public void testDelete() {
    HashCommandOperator.delete(User.class, 5L);
}

如此简单就把user:5删除了。

实现原理

实现原理不能再简单了，其实就是反射+注解

大致逻辑如下：

@Slf4j
public class HashCommandOperator {

    private static final String SUCCESS = "OK";
    private static final Long SUCCESS_CODE = 1L;
    private static final String EMPTY_STR = "HashCommandOperator_empty_str";

    private static final redis.clients.jedis.Jedis JEDIS = new redis.clients.jedis.Jedis("xxx", 6379);

    static {
        JEDIS.auth("xxx");
    }

    public static boolean upsert(Object obj) {
        val redisKey = getRedisKey(obj);
        val storeValues = getStoreValues(obj);
        val result = JEDIS.hmset(redisKey, storeValues);
        return SUCCESS.equals(result);
    }

    public static boolean delete(Class<?> clazz, Object id) {
        val keyPrefix = getKeyPrefix(clazz);
        val redisKey = keyPrefix + ":" + id;
        return Objects.equals(JEDIS.del(redisKey), SUCCESS_CODE);
    }

    @SuppressWarnings("all")
    public static <T> T query(Class<T> clazz, Object id) {
        val keyPrefix = getKeyPrefix(clazz);
        val redisKey = keyPrefix + ":" + id;
        val storeValueMap = JEDIS.hgetAll(redisKey);
        val filedName2Field = getStoreFields(clazz).stream()
            .collect(toMap(
                field -> getFiledName(field),
                Function.identity()
            ));
        try {
            final T o = clazz.newInstance();
            storeValueMap.forEach((k, v) -> {
                ofNullable(filedName2Field.get(k))
                    .ifPresent(f -> {
                        f.setAccessible(true);
                        try {
                            f.set(o, parseObject(v, f.getType()));
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    });
            });
            return (T) o;
        } catch (InstantiationException | IllegalAccessException e) {
            log.error("query error, queryKey : {}", redisKey, e);
            return null;
        }
    }

    @SuppressWarnings("all")
    private static Map<String, String> getStoreValues(Object obj) {
        val dataValues = getStoreFields(obj.getClass()).stream()
            .collect(
            toMap(
                field -> getFiledName(field),
                field -> {
                    field.setAccessible(true);
                    try {
                        return ofNullable(field.get(obj))
                            .map(fV -> {
                                return toJSONString(fV);
                            })
                            .orElse(EMPTY_STR);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                    return EMPTY_STR;
                }
            )
        );
        // 过滤到值为空的字段
        return dataValues.entrySet().stream()
            .filter(entry -> !EMPTY_STR.equals(entry.getValue()))
            .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
    }


    private static String getIdentityValue(Object t) {
        val identityFields = Arrays.stream(t.getClass().getDeclaredFields())
            .filter(field -> field.isAnnotationPresent(Identity.class))
            .collect(toList());
        if (identityFields.size() != 1) {
            throw new IllegalArgumentException("identity field must be one");
        }
        identityFields.get(0).setAccessible(true);
        try {
            return identityFields.get(0).get(t).toString();
        } catch (IllegalAccessException e) {
            log.error("getIdentityValue error, obj : {}", t, e);
            throw new RuntimeException(e);
        }
    }

    private static String getRedisKey(Object t) {
        return getKeyPrefix(t.getClass()) + ":" + getIdentityValue(t);
    }

    private static String getKeyPrefix(Class<?> clazz) {
        return ofNullable(clazz.getAnnotation(KeyPrefix.class))
            .map(KeyPrefix::value)
            .orElseGet(clazz::getSimpleName);
    }

    private static List<Field> getStoreFields(Class<?> clazz) {
        return Arrays.stream(clazz.getDeclaredFields())
            .filter(field -> {
                // 排除掉带有 StoreFiled 注解的 并且 StoreFiled.ignore == true
                return !(
                    field.isAnnotationPresent(StoreFiled.class) &&
                    field.getAnnotation(StoreFiled.class).ignore()
                );
            })
            .collect(toList());
    }

    private static String getFiledName(Field field) {
        return ofNullable(field.getAnnotation(StoreFiled.class))
            .map(StoreFiled::value)
            .orElseGet(field::getName);
    }
}