/**
 * 获取实体的ID泛型
 * @param entityClass
 * @return
 */
private static Class<?> getIdClass(Class<?> entityClass) {
    Type[] genTypes = entityClass.getGenericInterfaces();

    for (int i = 0; i < genTypes.length; i++) {
        Type genType = genTypes[i];
        String s1 = genType.getClass().getName();
        String s2 = BaseEntity.class.getName();
        if (s1.startsWith(s2)) {
            Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
            // ID真实的class
            Class<?> mapperClass = (Class<?>) params[0];
            return mapperClass;
        }
    }

    return null;
}
 

/**
 * 移除指定实体组指定key的缓存
 * @param entityClass
 * @param key
 */
   public static void removeCache(Class<? extends BaseEntity> entityClass,String key){
   	if(CacheHandler.cacheProvider == null)return;
   	String entityClassName = entityClass.getSimpleName();
	key = entityClassName + CacheHandler.DOT + key;
	CacheHandler.cacheProvider.remove(key);
}
 

/**
 * 生成查询缓存key
 * @param cacheInfo
 * @param param
 * @return
 */
@SuppressWarnings("unchecked")
private String genarateQueryCacheKey(String keyPattern,Object param){
	String text;
	try {
		Object[] args;
		if(param instanceof Map){
			Map<String, Object> map = (Map<String, Object>) param;
			if(map.containsKey(STR_PARAM + "1")){
				args = new String[map.size()/2];
				for (int i = 0; i < args.length; i++) {
					args[i] = CacheKeyUtils.objcetToString(map.get(STR_PARAM + (i+1)));
				}
			}else{
				args = new String[]{CacheKeyUtils.objcetToString(map)};
			}
		}else if(param instanceof BaseEntity){
			Serializable id = ((BaseEntity)param).getId();
			if(id != null && !"0".equals(id.toString())){	
				args = new String[]{(((BaseEntity)param).getId()).toString()};
			}else{
				args = new String[]{CacheKeyUtils.objcetToString(param)};
			}
		}else if(param instanceof Object[]){
			args = (Object[])param;
		}else if(param == null){
			args = new Object[0];
		}else{
			args = new String[]{CacheKeyUtils.objcetToString(param)};
		}
		
		text = StringUtils.join(args,"-");
	} catch (Exception e) {
		text = JsonUtils.toJson(param);
		e.printStackTrace();
	}
	if(text.length() > 64)text = DigestUtils.md5(text);

	return String.format(keyPattern, text);
}
 

public static <T extends BaseEntity> void addCache(T bean,int expireSeconds){
	String key = buildCacheKey(bean.getClass(), bean.getId());
	new RedisObject(key).set(bean, expireSeconds);
}
 

/**
 * 移除指定对象缓存
 * @param bean
 */
public static <T extends BaseEntity> void removeCache(T bean){
	if(CacheHandler.cacheProvider == null)return;
	String key = buildCacheKey(bean.getClass(), bean.getId());
	CacheHandler.cacheProvider.remove(key);
}
 

/**
 * 移除指定实体组所有缓存
 * @param entityClass
 */
public static void removeCache(Class<? extends BaseEntity> entityClass){
	if(CacheHandler.cacheProvider == null)return;
	String entityClassName = entityClass.getSimpleName();
}
 

@Override
public void start(JeesuiteMybatisInterceptor context) {
	
	nullValueCache = MybatisConfigs.getBoolean(context.getGroupName(), MybatisConfigs.CACHE_NULL_VALUE, false);
	dynamicCacheTime = MybatisConfigs.getBoolean(context.getGroupName(), MybatisConfigs.CACHE_DYNAMIC_EXPIRE, false);
	defaultCacheExpire = Long.parseLong(MybatisConfigs.getProperty(context.getGroupName(), MybatisConfigs.CACHE_EXPIRE_SECONDS, String.valueOf(IN_1HOUR)));
	logger.info("nullValueCache:{},defaultCacheExpireSeconds:{},dynamicCacheTime:{}",nullValueCache,defaultCacheExpire,dynamicCacheTime);

	List<EntityInfo> entityInfos = MybatisMapperParser.getEntityInfos(context.getGroupName());
	
	Class<BaseEntity> baseEntityClass = BaseEntity.class;
	QueryMethodCache methodCache = null;
	for (EntityInfo ei : entityInfos) {
		if(ei.getMapperClass().isAnnotationPresent(CacheIgnore.class))continue;
		if(!baseEntityClass.isAssignableFrom(ei.getEntityClass())){
			logger.warn("[{}] not extends from [{}],ignore register auto cache!!!!",ei.getEntityClass().getName(),baseEntityClass.getName());
			continue;
		}
		Class<?> mapperClass = ei.getMapperClass();
		
		//按主键查询方法定义
		QueryMethodCache queryByPKMethod = generateQueryByPKMethod(mapperClass, ei.getEntityClass());
		if(queryByPKMethod == null)continue;
		Map<String, QueryMethodCache> tmpMap = new HashMap<>();
		//主键查询方法
		tmpMap.put(queryByPKMethod.methodName, queryByPKMethod);
		
		String keyPatternForPK = queryByPKMethod.keyPattern;
		//接口定义的自动缓存方法
		for (MapperMethod method : ei.getMapperMethods()) {
			if(method.getMethod().isAnnotationPresent(Cache.class)){
				if(tmpMap.containsKey(method.getFullName()))continue;
				methodCache = generateQueryMethodCacheByMethod(ei, method);
				tmpMap.put(method.getFullName(), methodCache);
				logger.info("解析查询方法{}自动缓存配置 ok,keyPattern:[{}]",methodCache.methodName,methodCache.keyPattern);
			}
		}
		//缓存需要自动缓存的mapper
		cacheEnableMappers.add(ei.getMapperClass().getName());
		logger.info("解析查询方法{}自动缓存配置 ok,keyPattern:[{}]",queryByPKMethod.methodName,queryByPKMethod.keyPattern);
		
		queryCacheMethods.put(mapperClass.getName(), tmpMap);
		
		//更新缓存方法
		generateUpdateByPkCacheMethod(mapperClass, ei.getEntityClass(), keyPatternForPK);
	}
	//
	if(queryCacheMethods.isEmpty())return;
	//
	registerClearExpiredKeyTask();
}
 

/**
 * 查询并缓存结果(默认缓存一天)
 * @param entityClass 实体类class (用户组装实际的缓存key)
 * @param key 缓存的key（和entityClass一起组成真实的缓存key。<br>如entityClass=UserEntity.class,key=findlist，实际的key为：UserEntity.findlist）
 * @param dataCaller 缓存不存在数据加载源
 * @return
 */
public static <T> T queryTryCache(Class<? extends BaseEntity> entityClass,String key,Callable<T> dataCaller){
	return queryTryCache(entityClass, key, CacheHandler.defaultCacheExpire, dataCaller);
}