Redis+MyBatis自定义注解实现缓存

在数据库查询前我想查询是否存在缓存，不存在则查询，这样的重复性操作写在代码里很难看，通过AspectJ的AOP编程，可以很优雅地实现这个缓存过程。
但是在使用过程中，发现Spring自带的@Cacheable注解序列化对象时是使用JDK的序列化工具往Redis里存数据，这样很占Redis的内存，为何不用FastJSON之类的序列化工具序列化对象后往Redis里存JSON字符串呢，更加轻量快捷。
但是JSON在序列化和反序列化的时候需要提供类型，但是类型在SpringCache中并没有提供，那就自己做个吧！

/**
 * 缓存注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCache {

    /**
     * key的生成策略，支持表达式语言，表达式中多个值用"_"分隔
     * 不填写默认使用当前方法名
     * 例如       #name_#id
     * 最终生成SpEL表达式为     #name+'_'+#id
     */
    String field() default "";

    //JSON序列化的类型
    Class type();

    //默认缓存时间是一天 60*60*24
    long expire() default 86400L;
}

/**
 * 删除缓存注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisEvict {
    /**
     * key生成策略，可填写多个，对应于Hash映射中的field
     * 不填写默认删除以当前类全限定名作为key的Hash映射
     */
    String[] field() default {};

    Class type();
}

/**
 * Redis缓存切面处理
 */
@Aspect
@Component
public class RedisCacheAspect {
    @Resource
    private RedisTemplate redisTemplate;

    private final static Logger logger = Logger.getLogger(RedisCacheAspect.class);

    /**
     * 获取或添加缓存
     */
    @Around("@annotation(com.common.cache.redis.RedisCache)")
    public Object RedisCache(final ProceedingJoinPoint jp) throws Throwable {
        Method method = getMethod(jp);
        RedisCache cache = method.getAnnotation(RedisCache.class);
        //根据类名、方法名和参数生成key
        final String key = parseKey(cache.field(), method, jp.getArgs());
        if (logger.isDebugEnabled()) {
            logger.debug("生成key:" + key);
        }
        //得到被代理的方法上的注解
        Class modelType = method.getAnnotation(RedisCache.class).type();
        //检查redis是否有缓存
        String value = (String) redisTemplate.opsForHash().get(modelType.getName(), key);
        Object result;
        if (null == value) {
            //缓存未命中
            if (logger.isDebugEnabled()) {
                logger.debug("缓存未命中");
            }
            //去数据库查询
            result = jp.proceed(jp.getArgs());
            //把序列化结果放入缓存
            redisTemplate.opsForHash().put(modelType.getName(), key, serialize(result));
            //    设置失效时间
            redisTemplate.expire(modelType.getName(), cache.expire(), TimeUnit.SECONDS);
        } else {
            //缓存命中
            if (logger.isDebugEnabled()) {
                logger.debug("缓存命中");
            }
            //得到被代理方法的返回值类型
            Class returnType = ((MethodSignature) jp.getSignature()).getReturnType();
            //反序列化从缓存中拿到的json
            result = deserialize(value, returnType, modelType);
        }
        return result;
    }

    /**
     * 删除缓存
     */
    @Around("@annotation(com.common.cache.redis.RedisEvict)")
    public Object RedisEvict(final ProceedingJoinPoint jp) throws Throwable {
        //得到被代理的方法
        Method method = getMethod(jp);
        //得到被代理方法上的注解
        Class modelType = method.getAnnotation(RedisEvict.class).type();
        if (logger.isDebugEnabled()) {
            logger.debug("清空缓存:" + modelType.getName());
        }
        //判断是否指定了field
        String[] fields = method.getAnnotation(RedisEvict.class).field();
        if (fields.length == 0) {
            //清除类全限定名对应Hash缓存
            redisTemplate.delete(modelType.getName());
        } else {
            //清除指定的field的缓存
            List