import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * 清空缓存
 */
@Override
public void removeAll(){
	log.debug("@GenericCache remove all cache");
	Set<K> keys = getKeyHashOps().keys();
	if(keys.size() > 0){
		getKeyHashOps().delete(keys.toArray());//删除主键缓存
		
		if(unique != null){ //删除默认唯一键缓存
			getUniqueHashOps().delete(getUniqueHashOps().keys().toArray());
		}		
		
		for(String keyName: customKeys){ //删除自定义字段缓存
			BoundHashOperations<String, Object, V> map = customHashOpsHolder.get(keyName);
			if(map != null)
				map.delete(map.keys().toArray());
		}
	}
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
@Override
public V loadByCustom(String keyName, Object keyValue){
	if(StringUtils.isNotEmpty(keyName) && keyValue!=null){
		V v = null;
		BoundHashOperations<String, Object, V> customHashOps = customHashOpsHolder.get(coreConfig.getCtx()+Constants.COLON+clazz.getSimpleName()+Constants.COLON+keyName);
		if(customHashOps != null)
			v = customHashOps.get(keyValue);
		log.debug(String.format("@GenericCache get cache value with custom key name: %s and key value: %s and return value: %s ", keyName, keyValue, v));
		return v;
	}else{
		log.warn(String.format("@GenericCache cant not get cache value with empty keyName %s and empty keyValue %s",keyName,keyValue));
		return null;
	}
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
@Override
public <HK, HV> BoundHashOperations<K, HK, HV> boundHashOps(K key) {
	try {
		return redisTemplate.boundHashOps(key);
	} catch (Exception ex) {
		throw new RedisBaoException(ex);
	}
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
@Override
public BoundHashOperations<String, K, V> getKeyHashOps() {
	return getCacheService().getKeyHashOps();
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
@Override
public BoundHashOperations<String, Object, V> getUniqueHashOps() {
	return getCacheService().getUniqueHashOps();
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * @return the keyHashOps
 */
@Override
public BoundHashOperations<String, K, V> getKeyHashOps() {
	return keyHashOps;
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * @param keyHashOps the keyHashOps to set
 */
public void setKeyHashOps(BoundHashOperations<String, K, V> keyHashOps) {
	this.keyHashOps = keyHashOps;
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * @param uniqueHashOps the uniqueHashOps to set
 */
public void setUniqueHashOps(
		BoundHashOperations<String, Object, V> uniqueHashOps) {
	this.uniqueHashOps = uniqueHashOps;
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * @return the uniqueHashOps
 */
@Override
public BoundHashOperations<String, Object, V> getUniqueHashOps() {
	return uniqueHashOps;
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
@Override
public <HK, HV> BoundHashOperations<K, HK, HV> boundHashOps(K key) {
	throw new MethodNotSupportException("myRedisTemplate not support this method : boundHashOps(K key) , please use opsForXX");
	//return new DefaultBoundHashOperations<K, HK, HV>(key, this);
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
BoundHashOperations<byte[], byte[], Object> getHashOps(Serializable keyspace) {
	return redisOps.boundHashOps(converter.getConversionService().convert(keyspace, byte[].class));
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
public RedisRequestRepository(BoundHashOperations<String, String, Request> hashOps) {
    this.hashOps = hashOps;
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * Gets the {@link BoundHashOperations} to operate on a {@link Session}.
 * @param sessionId the id of the {@link Session} to work with
 * @return the {@link BoundHashOperations} to operate on a {@link Session}
 */
private BoundHashOperations<Object, Object, Object> getSessionBoundHashOperations(
		String sessionId) {
	String key = getSessionKey(sessionId);
	return this.sessionRedisOperations.boundHashOps(key);
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * 获取主键缓存Operations
 * @return
 */
BoundHashOperations<String, K, V> getKeyHashOps();
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * 获取唯一键缓存Operations
 * @return
 */
BoundHashOperations<String, Object, V> getUniqueHashOps();
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
/**
 * Return the {@link BoundHashOperations} operation for Redis.
 *
 * @return {@code BoundHashOperations} for Redis
 */
private BoundHashOperations<String, String, String> hashOps() {
	return this.redisOperations.boundHashOps("spring.cloud.resource.uri");
}
 

import org.springframework.data.redis.core.BoundHashOperations; //导入依赖的package包/类
<HK, HV> BoundHashOperations<K, HK, HV> boundHashOps(K key);