Spring Cache 中keyGenerator生成策略源码解析与自定义

雨点打透心脏的1/2处 2022-11-20 04:56 172阅读 0赞

# Spring Cache 中keyGenerator生成策略源码解析与自定义 #

## 一：源码解析 ##

> 解释：一个缓存名对应一个被注解的方法，但是一个方法可能传入不同的参数，那么结果也就会不同，这应该如何区分呢？这就需要用到 key 。在 spring 中，key 的生成有两种方式：显式指定和使用 keyGenerator 自动生成。

### 1、keyGenerator ###

keyGenerator生成器其实是一个接口，下面先看下其源码：

public interface KeyGenerator { 
    
    	/** * Generate a key for the given method and its parameters. * @param target the target instance * @param method the method being called * @param params the method parameters (with any var-args expanded) * @return a generated key */
    	Object generate(Object target, Method method, Object... params);
    
    }

### 2：DefaultKeyGenerator ###

当使用@Cacheable注解并且不显示指定key的时候就会调用默认实现类DefaultKeyGenerator

@Deprecated
    public class DefaultKeyGenerator implements KeyGenerator { 
    
    	public static final int NO_PARAM_KEY = 0;
    
    	public static final int NULL_PARAM_KEY = 53;
    
    
    	@Override
    	public Object generate(Object target, Method method, Object... params) { 
            //当没有参数时，返回 0（默认返回0）
    		if (params.length == 0) { 
    			return NO_PARAM_KEY;
    		}
            
    		if (params.length == 1) { 
    			Object param = params[0];
                //当有一个参数并且参数为空，则返回53（标识任意值）
    			if (param == null) { 
    				return NULL_PARAM_KEY;
    			}
                //如果参数不为空同时参数类型不是数组的时候，则返回当前参数本身
    			if (!param.getClass().isArray()) { 
    				return param;
    			}
    		}
            //其它情况 返回深度计算的 hashcode
    		return Arrays.deepHashCode(params);
    	}
    
    }

深度哈希Code？感觉很牛逼的样子，看看源码：

public static int deepHashCode(Object a[]) { 
        //如果参数为空，返回0
            if (a == null)
                return 0;
    
            int result = 1;
    
        //不为空，则遍历数组中所有元素，获取到所有元素的哈希值并且累计
            for (Object element : a) { 
                int elementHash = 0;
                if (element instanceof Object[])
                    elementHash = deepHashCode((Object[]) element);
                else if (element instanceof byte[])
                    elementHash = hashCode((byte[]) element);
                else if (element instanceof short[])
                    elementHash = hashCode((short[]) element);
                else if (element instanceof int[])
                    elementHash = hashCode((int[]) element);
                else if (element instanceof long[])
                    elementHash = hashCode((long[]) element);
                else if (element instanceof char[])
                    elementHash = hashCode((char[]) element);
                else if (element instanceof float[])
                    elementHash = hashCode((float[]) element);
                else if (element instanceof double[])
                    elementHash = hashCode((double[]) element);
                else if (element instanceof boolean[])
                    elementHash = hashCode((boolean[]) element);
                else if (element != null)
                    elementHash = element.hashCode();
    
                result = 31 * result + elementHash;
            }
    
            return result;
        }

看到这里有没有小伙伴和我有一样的疑惑，result = 31 \* result + elementHash中，31到底是干啥用的？？？通过查询资料可知：

原因：因为任何数n * 31就可以被JVM优化为 (n << 5) -n,移位和减法的操作效率要比乘法的操作效率高的多
        
    补充下hashCode基础知识：
        （1）hashCode是用来在散列存储结构中确定对象的存储地址，能快速的查找；
        （2）两个对象相同，那么hashCode 一定相同，但是两个hashCode相同的对象不一样相同；
        （3）如果重写对象的equals方法，那么也尽量重写对象的hashCode方法；

### 3、SimpleKeyGenerator ###

spring中还有一个简单的生成策略，原理和上面的基本一样，源码如下：

public class SimpleKeyGenerator implements KeyGenerator {
    
    	@Override
    	public Object generate(Object target, Method method, Object... params) {
    		return generateKey(params);
    	}
    
    	/**
    	 * Generate a key based on the specified parameters.
    	 */
    	public static Object generateKey(Object... params) {
    		if (params.length == 0) {
    			return SimpleKey.EMPTY;
    		}
    		if (params.length == 1) {
    			Object param = params[0];
    			if (param != null && !param.getClass().isArray()) {
    				return param;
    			}
    		}
    		return new SimpleKey(params);
    	}
    
    }

public class SimpleKey implements Serializable { 
    
    	public static final SimpleKey EMPTY = new SimpleKey();
    
    	private final Object[] params;
    	private final int hashCode;
    
    
    	/** * Create a new {@link SimpleKey} instance. * @param elements the elements of the key */
    	public SimpleKey(Object... elements) { 
    		Assert.notNull(elements, "Elements must not be null");
    		this.params = new Object[elements.length];
    		System.arraycopy(elements, 0, this.params, 0, elements.length);
    		this.hashCode = Arrays.deepHashCode(this.params);
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		return (this == obj || (obj instanceof SimpleKey
    				&& Arrays.deepEquals(this.params, ((SimpleKey) obj).params)));
    	}
    
    	@Override
    	public final int hashCode() { 
    		return this.hashCode;
    	}
    
    	@Override
    	public String toString() { 
    		return getClass().getSimpleName() + " [" + StringUtils.arrayToCommaDelimitedString(this.params) + "]";
    	}
    }

## 二：自定义KeyGenerator ##

> 如在参数为map时，要求map里的所有key-value组合作为一个key来做缓存；

@Component
    public class MyKeyGenerator implements KeyGenerator { 
     
        @Override
        public Object generate(Object target, Method method, Object... params) { 
            if (params.length == 0) { 
                return SimpleKey.EMPTY;
            }
            Object param = params[0];
            // 参数为map自定义key=类名+方法名+map的key-value值
            if (param instanceof Map) { 
                StringBuilder builder = new StringBuilder();
                String sp = ".";
                builder.append(target.getClass().getSimpleName()).append(sp);
                builder.append(method.getName()).append(sp);
                Map<String, Object> map = (Map<String, Object>) param;
                if (map.isEmpty()) { 
                    return builder.toString();
                }
                for (String key : map.keySet()) { 
                    builder.append(key).append("-").append(map.get(key)).append(sp);
                }
                return builder.toString();
            }
            return new SimpleKey(params);
        }
    }

参考博文：  
[SpringBoot+SpringCache+Redis整合，自定义KeyGenerator生成器，@Cacheable设置单个key的缓存时间][SpringBoot_SpringCache_Redis_KeyGenerator_Cacheable_key]

[SpringBoot_SpringCache_Redis_KeyGenerator_Cacheable_key]: https://blog.csdn.net/qq_42420773/article/details/103870662?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.edu_weight&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.edu_weight#%C2%A0%201.%E9%9B%86%E6%88%90SpringCache,%E8%87%AA%E9%9C%80%E8%A6%81%E5%9C%A8pom%E4%B8%AD%E5%8A%A0%E5%85%A5%E4%BB%A5%E4%B8%8B%E4%BE%9D%E8%B5%96%EF%BC%9A