spring cache,基本能够满足一般应用对缓存的需求,但现实总是很复杂,当你的用户量上去或者性能跟不上,总需要进行扩展,这个时候你或许对其提供的内存缓存不满意了,因为其不支持高可用性,也不具备持久化数据能力,这个时候,你就需要自定义你的缓存方案了,还好,spring 也想到了这一点。
本篇文章采用spring cache与redis进行整合,实现自己想要的缓存。
我们先配置redis:
第一步,要安装redis,这个自行百度,我们主要是配置redis。
增加一个redis配置文件,可以放在跟目录下
redis.host=192.168.0.43
redis.port=6379
redis.pass=2015
redis.maxIdle=50
redis.maxActive=50
redis.maxWait=50
redis.testOnBorrow=true
redis.timeout=1000
还需要在spring的配置文件中去配置redis
好了,配置redis完成了。
现在我们来配置spring的cache:
其实上面的配置文件,已经把redis与spring注解缓存的关系配置到了spring的xml文件中了。
对应的SystemRedisCache类是一个实现cache接口的自定义的缓存实现类。
import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
/**
* 〈一句话功能简述〉
* 〈功能详细描述〉
*
* @author Administrator
* @see [相关类/方法](可选)
* @since [产品/模块版本] (可选)
*/
public class SystemRedisCache implements Cache {
/**
* Redis
*/
private RedisTemplate redisTemplate;
/**
* 缓存名称
*/
private String name;
/**
* 超时时间
*/
private long timeout;
/*
* (non-Javadoc)
* @see org.springframework.cache.Cache#getName()
*/
@Override
public String getName() {
return this.name;
}
/*
* (non-Javadoc)
* @see org.springframework.cache.Cache#getNativeCache()
*/
@Override
public Object getNativeCache() {
// TODO Auto-generated method stub
return this.redisTemplate;
}
/*
* (non-Javadoc)
* @see org.springframework.cache.Cache#get(java.lang.Object)
*/
@Override
public ValueWrapper get(Object key) {
if (StringUtils.isEmpty(key)) {
return null;
} else {
final String finalKey;
if (key instanceof String) {
finalKey = (String) key;
} else {
finalKey = key.toString();
}
Object object = null;
object = redisTemplate.execute(new RedisCallback
现在有个问题,我们发现,在spring配置自己的注解缓存的配置文件中配置了多个cache,那spring是怎么去找到对应的cacheManager呢?
我们直接以代码给大家呈现出来:
/**
*
* 公共接口
*
* @author Administrator
* @see [相关类/方法](可选)
* @since [产品/模块版本] (可选)
*/
@Service("commonService")
public class CommonServiceImpl implements CommonService {
/**
* 日志记录器
*/
private static final Logger LOGGER = LoggerFactory.getLogger(CommonServiceImpl.class);
@Autowired
private DalClient dalClient;
/*
* @Autowired RedisTemplate, ?> redisTemplate;
*/
/**
* 根据名称获取自增序列squence的当前值
*
* @param SequenceName 自增序列名称
* @return 自增序列当前值
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
public String getSequenceByName(String SequenceName) {
if (StringUtils.isEmpty(SequenceName)) {
LOGGER.error("自增序列名称为空,无法返回正常的自增序列值");
return null;
} else {
Map paramMap = new HashMap();
paramMap.put("sequenceName", SequenceName);
// 查询sequence当前值
Map resultMap = dalClient.queryForMap("common.GET_SEQUENCE_BY_NAME", paramMap);
if (null != resultMap && !resultMap.isEmpty()) {
return String.valueOf(resultMap.get("sequenceValue"));
} else {
return null;
}
}
}
/**
* 根据上一级的城市编码 查询 所有下属城市 列表
*
* @param parentCityCode
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.queryCityListByParentCode", key = "new String('commonService.queryCityListByParentCode')+#parentCityCode.toString()", condition = "null != #parentCityCode")
public List queryCityListByParentCode(final Integer parentCityCode) {
Map paramMap = new HashMap();
if (null != parentCityCode) {
// 根据所选省份 \ 城市 查询所属城市列表
paramMap.put("parentCityCode", parentCityCode);
final List cityListResult = dalClient.queryForList("T_CITY.SELECT_BY_PARENTCODE", paramMap,
CityBean.class);
return cityListResult;
} else {
final List provinceListResult = dalClient.queryForList("T_CITY.SELECT_ALL_FIRST_STEP_CITY",
paramMap, CityBean.class);
return provinceListResult;
}
}
/**
* 根据上一级的行业编码 查询 所有下属所有行业
*
* @param parentCityCode
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.queryIndustryListByParentCode", key = "new String('commonService.queryIndustryListByParentCode')+#parentIndustryCode.toString", condition = "null != #parentIndustryCode")
public List queryIndustryListByParentCode(final Integer parentIndustryCode) {
Map paramMap = new HashMap();
if (null != parentIndustryCode) {
paramMap.put("parentIndustryCode", parentIndustryCode);
final List industryListResult = dalClient.queryForList("T_INDUSTRY.SELECT_BY_PARENTCODE",
paramMap, IndustryBean.class);
return industryListResult;
} else {
final List industryListResult = dalClient.queryForList(
"T_INDUSTRY.SELECT_ALL_FIRST_STEP_INDUSTRY", paramMap, IndustryBean.class);
return industryListResult;
}
}
/**
* 根据行业编码查询 行业信息
*
* @param industryCode
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.queryIndustryInfoById", key = "new String('commonService.queryIndustryInfoById')+#industryCode", condition = "(null != #industryCode) and (#industryCode.length() > 0)")
public IndustryBean queryIndustryInfoById(final String industryCode) {
if (StringUtils.isEmpty(industryCode)) {
return null;
} else {
Map paramMap = new HashMap();
paramMap.put("industryCode", industryCode);
final IndustryBean industryInfoResult = dalClient.queryForObject("T_INDUSTRY.SELECT_BY_ID", paramMap,
IndustryBean.class);
return industryInfoResult;
}
}
/**
* 递归删除 元素 因为可能存在重复的
*
* @param list 列表
* @param item 要删除的元素
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
private void deleteListElement(ArrayList list, String item) {
if (null != list && !list.isEmpty() && StringUtils.isNotBlank(item)) {
if (list.contains(item)) {
list.remove(item);
if (list.contains(item)) {
deleteListElement(list, item);
}
}
}
}
/**
* 根据行业id查询 行业名称
*
* @param industryIds 行业Id可能有多个 以分号分隔
* @return 行业名称列表
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.queryIndustryNameByIds", key = "new String('commonService.queryIndustryNameByIds')+#industryIds", condition = "null != #industryIds and #industryIds.length() > 0")
public List queryIndustryNameByIds(final String industryIds) {
if (StringUtils.isBlank(industryIds)) {
return null;
} else {
String[] industryIdArr = industryIds.split(";");
if (null != industryIdArr && industryIdArr.length > 0) {
ArrayList paramList = new ArrayList();
paramList.addAll(Arrays.asList(industryIdArr));
if (null != paramList && !paramList.isEmpty()) {
Map paramMap = new HashMap();
paramMap.put("industryIdList", paramList);
// 查询行业列表
List queryResultList = dalClient.queryForList("T_INDUSTRY.SELECT_BY_ID_LIST",
paramMap, IndustryBean.class);
// 封装查询结果
List industryNameList = new ArrayList();
if (null != queryResultList && !queryResultList.isEmpty()) {
// 遍历查询列表 将已经存在的编码去掉 剩下的 就是 根據编码查询不出行业的 直接将行业的名字返回
String tempId;
for (IndustryBean industryInfo : queryResultList) {
if (null != industryInfo) {
if (null == industryInfo.getIndustryCode()) {
continue;
} else {
tempId = industryInfo.getIndustryCode().toString();
if (paramList.contains(tempId)) {
deleteListElement(paramList, tempId);
}
if (StringUtils.isNotBlank(industryInfo.getIndustryName())) {
industryNameList.add(industryInfo.getIndustryName());
}
}
}
}
}
// 将根据编码查询不出来 的 行业编码 直接返回
industryNameList.addAll(paramList);
return industryNameList;
}
}
return null;
}
}
/**
* 根据城市id查询 城市名称
*
* @param industryIds 行业Id可能有多个 以分号分隔
* @return 行业名称列表
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.queryCityNameByIds", key = "new String('commonService.queryCityNameByIds')+#cityIds", condition = "null != #cityIds and #cityIds.length() > 0")
public List queryCityNameByIds(String cityIds) {
if (StringUtils.isBlank(cityIds)) {
return null;
} else {
String replacyedCityIds = cityIds.replace(";", ",");
String[] industryIdArr = replacyedCityIds.split(",");
if (null != industryIdArr && industryIdArr.length > 0) {
ArrayList paramList = new ArrayList();
paramList.addAll(Arrays.asList(industryIdArr));
if (null != paramList && !paramList.isEmpty()) {
Map paramMap = new HashMap();
paramMap.put("cityIdList", paramList);
// 查询行业列表
List queryResultList = dalClient.queryForList("T_CITY.SELECT_BY_ID_LIST", paramMap,
CityBean.class);
List industryNameList = new ArrayList();
if (null != queryResultList && !queryResultList.isEmpty()) {
// 遍历查询列表 将已经存在的编码去掉 剩下的 就是 根據编码查询不出行业的 直接将行业的名字返回
// 封装查询结果
String tempId;
for (CityBean industryInfo : queryResultList) {
if (null != industryInfo) {
if (null == industryInfo.getCityCode()) {
continue;
} else {
tempId = industryInfo.getCityCode().toString();
if (paramList.contains(tempId)) {
deleteListElement(paramList, tempId);
}
if (StringUtils.isNotBlank(industryInfo.getCityName())) {
industryNameList.add(industryInfo.getCityName());
}
}
}
}
}
// 将根据编码查询不出来 的 行业编码 直接返回
industryNameList.addAll(paramList);
return industryNameList;
}
}
return null;
}
}
/**
* 查询第一级所有职位
*
* @return
*/
@Override
public List queryFirstJobList() {
/*
* List redisIndustryListResult = redisTemplate.execute(new RedisCallback>() {
* @Override public List doInRedis(RedisConnection connection) { byte[] industryListList =
* connection.get((RedisConstants.JOB_FIRST_LIST).getBytes()); if (null != industryListList &&
* industryListList.length > 0) { return (List) SerializableObjectUtil.unserialize(industryListList);
* } else { return null; } } }); if (null != redisIndustryListResult && !redisIndustryListResult.isEmpty()) {
* return redisIndustryListResult; } else {
*/
final List queryIndustryListResult = dalClient.queryForList("T_JOB_TYPE.SELECT_FIRST_JOB_CODE",
null, JobTypeVo.class);
/*
* if (null != queryIndustryListResult && !queryIndustryListResult.isEmpty()) { redisTemplate.execute(new
* RedisCallback() {
* @Override public Boolean doInRedis(RedisConnection connection) {
* connection.set((RedisConstants.JOB_FIRST_LIST).getBytes(),
* SerializableObjectUtil.serialize(queryIndustryListResult)); return true; } }); }
*/
return queryIndustryListResult;
/* } */
}
/**
* 查询 对应级别的职位信息
*
* @param typeValue
* @param jobCode
* @return
*/
@Override
public List queryJobTypeList(final int typeValue, final int jobCode) {
/*
* List redisIndustryListResult = redisTemplate.execute(new RedisCallback>() {
* @Override public List doInRedis(RedisConnection connection) { byte[] industryListList =
* connection.get((RedisConstants.JOB_FIRST_LIST + typeValue + jobCode) .getBytes()); if (null !=
* industryListList && industryListList.length > 0) { return (List)
* SerializableObjectUtil.unserialize(industryListList); } else { return null; } } }); if (null !=
* redisIndustryListResult && !redisIndustryListResult.isEmpty()) { return redisIndustryListResult; } else {
*/
Map paramMap = new HashMap();
paramMap.put("typeValue", typeValue);
paramMap.put("jobFirstCode", jobCode);
final List queryResult = dalClient.queryForList("T_JOB_TYPE.SELECT_BY_JOB_CODE", paramMap,
JobTypeBean.class);
/*
* if (null != queryResult && !queryResult.isEmpty()) { redisTemplate.execute(new RedisCallback() {
* @Override public Boolean doInRedis(RedisConnection connection) {
* connection.set((RedisConstants.JOB_FIRST_LIST + typeValue + jobCode).getBytes(),
* SerializableObjectUtil.serialize(queryResult)); return true; } }); }
*/
return queryResult;
/* } */
}
/**
* 判断学校是否 特殊学校
*
* @param schoolName 学校名称
* @param schoolType 学校分类(1:211 暂无其他)
* @return true:是, false:否
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.isSpecialSchool", key = "new String('commonService.isSpecialSchool')+#schoolName + #schoolType", condition = "null != #schoolName and null !=#schoolType and #schoolName.length() > 0")
public boolean isSpecialSchool(String schoolName, int schoolType) {
if (StringUtils.isEmpty(schoolName)) {
return false;
} else {
Map paramMap = new HashMap();
paramMap.put("schoolName", schoolName);
paramMap.put("schoolType", schoolType);
Map resultMap = dalClient.queryForMap("T_MY_SPECIAL_SCHOOL.SELECT_BY_NAME_TYPE", paramMap);
if (null != resultMap && !resultMap.isEmpty() && resultMap.containsKey("NUM")) {
return (long) resultMap.get("NUM") > 0;
} else {
return false;
}
}
}
/**
* 根据城市名称获取 城市所在 省份名称
*
* @param cityNames
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Override
@Cacheable(value = "commonService.getProvinceByCity", key = "new String('commonService.getProvinceByCity')+#cityNames", condition = "null != #cityNames and #cityNames.length() > 0")
public String getProvinceByCity(final String cityNames) {
if (StringUtils.isBlank(cityNames)) {
return null;
} else {
String[] cityArr = cityNames.split("、");
Map paramMap = new HashMap();
Map resultMap;
String provinceName;
List provinceLait = new ArrayList();
for (String cityName : cityArr) {
if (StringUtils.isNotBlank(cityName)) {
paramMap.put("cityName", cityName);
resultMap = dalClient.queryForMap("T_CITY.SELECT_PROVINCE_NAMEBY_CITY_NAME", paramMap);
if (null != resultMap && !resultMap.isEmpty() && resultMap.containsKey("provinceName")) {
provinceName = String.valueOf(resultMap.get("provinceName"));
if (!provinceLait.contains(provinceName)) {
provinceLait.add(provinceName);
}
}
}
}
StringBuffer sb = new StringBuffer(100);
if (!provinceLait.isEmpty()) {
for (int i = 0; i < provinceLait.size(); i++) {
if (i < provinceLait.size() - 1) {
sb.append(provinceLait.get(i)).append(",");
} else {
sb.append(provinceLait.get(i));
}
}
}
return sb.toString();
}
}
已queryCityListByParentCode方法为例:
在这个方法上面有@Cacheable这个注解,这个是spring3.1以后增加的注解缓存标签,它会根据value = "commonService.queryCityListByParentCode"中value的属性值去查找我们配置在spring的xml文件中的name属性去查找,找到对应的配置文件后,该方法会通过我们自定义的缓存实现类去实现对应的逻辑,如果对spring注解的意义不清楚的可以先去了解下spring cache注解的含义。
好了,spring cache与redis的缓存整合就ok了