wezone
/
Ry-master
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

update 优化参数&字典缓存操作

This commit is contained in:
疯狂的狮子li 2021-05-28 10:30:11 +08:00
parent 8d6c9e116d
commit 7779cbca4d
4 changed files with 454 additions and 465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
View File

@ -1,8 +1,11 @@
package com.ruoyi.system.mapper; package com.ruoyi.system.mapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.core.domain.entity.SysDictData; import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.page.BaseMapperPlus; import com.ruoyi.common.core.page.BaseMapperPlus;
import java.util.List;
/** /**
* 字典表 数据层 * 字典表 数据层
* *
@ -10,4 +13,11 @@ import com.ruoyi.common.core.page.BaseMapperPlus;
*/ */
public interface SysDictDataMapper extends BaseMapperPlus<SysDictData> { public interface SysDictDataMapper extends BaseMapperPlus<SysDictData> {
default List<SysDictData> selectDictDataByType(String dictType) {
return selectList(
new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getStatus, "0")
.eq(SysDictData::getDictType, dictType)
.orderByAsc(SysDictData::getDictSort));
}
} }

345
ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
View File

@ -20,7 +20,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -37,191 +36,187 @@ public class SysConfigServiceImpl extends ServiceImpl<SysConfigMapper, SysConfig
private SysConfigMapper configMapper; private SysConfigMapper configMapper;
@Autowired @Autowired
private RedisCache redisCache; private RedisCache redisCache;
/** /**
* 项目启动时，初始化参数到缓存 * 项目启动时，初始化参数到缓存
*/ */
@PostConstruct @PostConstruct
public void init() { public void init() {
loadingConfigCache(); loadingConfigCache();
} }
@Override @Override
public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) { public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) {
Map<String, Object> params = config.getParams(); Map<String, Object> params = config.getParams();
LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>() LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName()) .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType()) .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey()) .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
.apply(Validator.isNotEmpty(params.get("beginTime")), .apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime")) params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")), .apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime")); params.get("endTime"));
return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw)); return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
} }
/** /**
* 查询参数配置信息 * 查询参数配置信息
* *
* @param configId 参数配置ID * @param configId 参数配置ID
* @return 参数配置信息 * @return 参数配置信息
*/ */
@Override @Override
@DataSource(DataSourceType.MASTER) @DataSource(DataSourceType.MASTER)
public SysConfig selectConfigById(Long configId) { public SysConfig selectConfigById(Long configId) {
return baseMapper.selectById(configId); return baseMapper.selectById(configId);
} }
/** /**
* 根据键名查询参数配置信息 * 根据键名查询参数配置信息
* *
* @param configKey 参数key * @param configKey 参数key
* @return 参数键值 * @return 参数键值
*/ */
@Override @Override
public String selectConfigByKey(String configKey) { public String selectConfigByKey(String configKey) {
String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey))); String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey)));
if (Validator.isNotEmpty(configValue)) { if (Validator.isNotEmpty(configValue)) {
return configValue; return configValue;
} }
SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>() SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>()
.eq(SysConfig::getConfigKey, configKey)); .eq(SysConfig::getConfigKey, configKey));
if (Validator.isNotNull(retConfig)) { if (Validator.isNotNull(retConfig)) {
redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue()); redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
return retConfig.getConfigValue(); return retConfig.getConfigValue();
} }
return StrUtil.EMPTY; return StrUtil.EMPTY;
} }
/** /**
* 查询参数配置列表 * 查询参数配置列表
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 参数配置集合 * @return 参数配置集合
*/ */
@Override @Override
public List<SysConfig> selectConfigList(SysConfig config) { public List<SysConfig> selectConfigList(SysConfig config) {
Map<String, Object> params = config.getParams(); Map<String, Object> params = config.getParams();
LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>() LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName()) .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType()) .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey()) .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
.apply(Validator.isNotEmpty(params.get("beginTime")), .apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime")) params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")), .apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime")); params.get("endTime"));
return baseMapper.selectList(lqw); return baseMapper.selectList(lqw);
} }
/** /**
* 新增参数配置 * 新增参数配置
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int insertConfig(SysConfig config) { public int insertConfig(SysConfig config) {
int row = baseMapper.insert(config); int row = baseMapper.insert(config);
if (row > 0) { if (row > 0) {
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
} }
return row; return row;
} }
/** /**
* 修改参数配置 * 修改参数配置
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int updateConfig(SysConfig config) { public int updateConfig(SysConfig config) {
int row = baseMapper.updateById(config); int row = baseMapper.updateById(config);
if (row > 0) { if (row > 0) {
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
} }
return row; return row;
} }
/** /**
* 批量删除参数信息 * 批量删除参数信息
* *
* @param configIds 需要删除的参数ID * @param configIds 需要删除的参数ID
* @return 结果 * @return 结果
*/ */
@Override @Override
public void deleteConfigByIds(Long[] configIds) { public void deleteConfigByIds(Long[] configIds) {
for (Long configId : configIds) { for (Long configId : configIds) {
SysConfig config = selectConfigById(configId); SysConfig config = selectConfigById(configId);
if (StrUtil.equals(UserConstants.YES, config.getConfigType())) { if (StrUtil.equals(UserConstants.YES, config.getConfigType())) {
throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey())); throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
} }
configMapper.deleteConfigById(configId); configMapper.deleteById(configId);
redisCache.deleteObject(getCacheKey(config.getConfigKey())); redisCache.deleteObject(getCacheKey(config.getConfigKey()));
} }
} }
/** /**
* 加载参数缓存数据 * 加载参数缓存数据
*/ */
@Override @Override
public void loadingConfigCache() public void loadingConfigCache() {
{ List<SysConfig> configsList = selectConfigList(new SysConfig());
List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig()); for (SysConfig config : configsList) {
for (SysConfig config : configsList) redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
{ }
redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); }
}
}
/** /**
* 清空参数缓存数据 * 清空参数缓存数据
*/ */
@Override @Override
public void clearConfigCache() public void clearConfigCache() {
{ Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*");
Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*"); redisCache.deleteObject(keys);
redisCache.deleteObject(keys); }
}
/** /**
* 重置参数缓存数据 * 重置参数缓存数据
*/ */
@Override @Override
public void resetConfigCache() public void resetConfigCache() {
{ clearConfigCache();
clearConfigCache(); loadingConfigCache();
loadingConfigCache(); }
}
/** /**
* 校验参数键名是否唯一 * 校验参数键名是否唯一
* *
* @param config 参数配置信息 * @param config 参数配置信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public String checkConfigKeyUnique(SysConfig config) { public String checkConfigKeyUnique(SysConfig config) {
Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId(); Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId();
SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey())); SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey()));
if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) { if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
} }
return UserConstants.UNIQUE; return UserConstants.UNIQUE;
} }
/** /**
* 设置cache key * 设置cache key
* *
* @param configKey 参数键 * @param configKey 参数键
* @return 缓存键key * @return 缓存键key
*/ */
private String getCacheKey(String configKey) { private String getCacheKey(String configKey) {
return Constants.SYS_CONFIG_KEY + configKey; return Constants.SYS_CONFIG_KEY + configKey;
} }
} }

196
ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
View File

@ -11,7 +11,6 @@ import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.service.ISysDictDataService; import com.ruoyi.system.service.ISysDictDataService;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List; import java.util.List;
/** /**
@ -22,112 +21,103 @@ import java.util.List;
@Service @Service
public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService { public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService {
@Autowired @Override
private SysDictDataMapper dictDataMapper; public TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData) {
LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>()
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort);
return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
}
@Override /**
public TableDataInfo<SysDictData> selectPageDictDataList(SysDictData dictData) { * 根据条件分页查询字典数据
LambdaQueryWrapper<SysDictData> lqw = new LambdaQueryWrapper<SysDictData>() *
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType()) * @param dictData 字典数据信息
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel()) * @return 字典数据集合信息
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus()) */
.orderByAsc(SysDictData::getDictSort); @Override
return PageUtils.buildDataInfo(page(PageUtils.buildPage(),lqw)); public List<SysDictData> selectDictDataList(SysDictData dictData) {
} return list(new LambdaQueryWrapper<SysDictData>()
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType())
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel())
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus())
.orderByAsc(SysDictData::getDictSort));
}
/** /**
* 根据条件分页查询字典数据 * 根据字典类型和字典键值查询字典数据信息
* *
* @param dictData 字典数据信息 * @param dictType 字典类型
* @return 字典数据集合信息 * @param dictValue 字典键值
*/ * @return 字典标签
@Override */
public List<SysDictData> selectDictDataList(SysDictData dictData) { @Override
return list(new LambdaQueryWrapper<SysDictData>() public String selectDictLabel(String dictType, String dictValue) {
.eq(StrUtil.isNotBlank(dictData.getDictType()), SysDictData::getDictType, dictData.getDictType()) return getOne(new LambdaQueryWrapper<SysDictData>()
.like(StrUtil.isNotBlank(dictData.getDictLabel()), SysDictData::getDictLabel, dictData.getDictLabel()) .select(SysDictData::getDictLabel)
.eq(StrUtil.isNotBlank(dictData.getStatus()), SysDictData::getStatus, dictData.getStatus()) .eq(SysDictData::getDictType, dictType)
.orderByAsc(SysDictData::getDictSort)); .eq(SysDictData::getDictValue, dictValue))
} .getDictLabel();
}
/** /**
* 根据字典类型和字典键值查询字典数据信息 * 根据字典数据ID查询信息
* *
* @param dictType 字典类型 * @param dictCode 字典数据ID
* @param dictValue 字典键值 * @return 字典数据
* @return 字典标签 */
*/ @Override
@Override public SysDictData selectDictDataById(Long dictCode) {
public String selectDictLabel(String dictType, String dictValue) { return getById(dictCode);
return getOne(new LambdaQueryWrapper<SysDictData>() }
.select(SysDictData::getDictLabel)
.eq(SysDictData::getDictType, dictType)
.eq(SysDictData::getDictValue, dictValue))
.getDictLabel();
}
/** /**
* 根据字典数据ID查询信息 * 批量删除字典数据信息
* *
* @param dictCode 字典数据ID * @param dictCodes 需要删除的字典数据ID
* @return 字典数据 * @return 结果
*/ */
@Override @Override
public SysDictData selectDictDataById(Long dictCode) { public void deleteDictDataByIds(Long[] dictCodes) {
return getById(dictCode); for (Long dictCode : dictCodes) {
} SysDictData data = selectDictDataById(dictCode);
baseMapper.deleteById(dictCode);
List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDatas);
}
}
/** /**
* 批量删除字典数据信息 * 新增保存字典数据信息
* *
* @param dictCodes 需要删除的字典数据ID * @param data 字典数据信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public void deleteDictDataByIds(Long[] dictCodes) public int insertDictData(SysDictData data) {
{ int row = baseMapper.insert(data);
for (Long dictCode : dictCodes) if (row > 0) {
{ List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
SysDictData data = selectDictDataById(dictCode); DictUtils.setDictCache(data.getDictType(), dictDatas);
dictDataMapper.deleteDictDataById(dictCode); }
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType()); return row;
DictUtils.setDictCache(data.getDictType(), dictDatas); }
}
}
/** /**
* 新增保存字典数据信息 * 修改保存字典数据信息
* *
* @param data 字典数据信息 * @param data 字典数据信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int insertDictData(SysDictData data) public int updateDictData(SysDictData data) {
{ int row = baseMapper.updateById(data);
int row = baseMapper.insert(data); if (row > 0) {
if (row > 0) List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
{ DictUtils.setDictCache(data.getDictType(), dictDatas);
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType()); }
DictUtils.setDictCache(data.getDictType(), dictDatas); return row;
} }
return row;
}
/**
* 修改保存字典数据信息
*
* @param data 字典数据信息
* @return 结果
*/
@Override
public int updateDictData(SysDictData data)
{
int row = baseMapper.updateById(data);
if (row > 0)
{
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
DictUtils.setDictCache(data.getDictType(), dictDatas);
}
return row;
}
} }

368
ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
View File

@ -21,7 +21,6 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -36,210 +35,205 @@ public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDi
@Autowired @Autowired
private SysDictTypeMapper dictTypeMapper; private SysDictTypeMapper dictTypeMapper;
@Autowired @Autowired
private SysDictDataMapper dictDataMapper; private SysDictDataMapper dictDataMapper;
/** /**
* 项目启动时，初始化字典到缓存 * 项目启动时，初始化字典到缓存
*/ */
@PostConstruct @PostConstruct
public void init() { public void init() {
loadingDictCache(); loadingDictCache();
} }
@Override @Override
public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) { public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) {
Map<String, Object> params = dictType.getParams(); Map<String, Object> params = dictType.getParams();
LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>() LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
.like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName()) .like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
.eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus()) .eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
.like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType()) .like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
.apply(Validator.isNotEmpty(params.get("beginTime")), .apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime")) params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")), .apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime")); params.get("endTime"));
return PageUtils.buildDataInfo(page(PageUtils.buildPage(),lqw)); return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
} }
/** /**
* 根据条件分页查询字典类型 * 根据条件分页查询字典类型
* *
* @param dictType 字典类型信息 * @param dictType 字典类型信息
* @return 字典类型集合信息 * @return 字典类型集合信息
*/ */
@Override @Override
public List<SysDictType> selectDictTypeList(SysDictType dictType) { public List<SysDictType> selectDictTypeList(SysDictType dictType) {
Map<String, Object> params = dictType.getParams(); Map<String, Object> params = dictType.getParams();
return list(new LambdaQueryWrapper<SysDictType>() return list(new LambdaQueryWrapper<SysDictType>()
.like(StrUtil.isNotBlank(dictType.getDictName()),SysDictType::getDictName, dictType.getDictName()) .like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
.eq(StrUtil.isNotBlank(dictType.getStatus()),SysDictType::getStatus, dictType.getStatus()) .eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
.like(StrUtil.isNotBlank(dictType.getDictType()),SysDictType::getDictType, dictType.getDictType()) .like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
.apply(Validator.isNotEmpty(params.get("beginTime")), .apply(Validator.isNotEmpty(params.get("beginTime")),
"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
params.get("beginTime")) params.get("beginTime"))
.apply(Validator.isNotEmpty(params.get("endTime")), .apply(Validator.isNotEmpty(params.get("endTime")),
"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')", "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
params.get("endTime"))); params.get("endTime")));
} }
/** /**
* 根据所有字典类型 * 根据所有字典类型
* *
* @return 字典类型集合信息 * @return 字典类型集合信息
*/ */
@Override @Override
public List<SysDictType> selectDictTypeAll() { public List<SysDictType> selectDictTypeAll() {
return list(); return list();
} }
/** /**
* 根据字典类型查询字典数据 * 根据字典类型查询字典数据
* *
* @param dictType 字典类型 * @param dictType 字典类型
* @return 字典数据集合信息 * @return 字典数据集合信息
*/ */
@Override @Override
public List<SysDictData> selectDictDataByType(String dictType) { public List<SysDictData> selectDictDataByType(String dictType) {
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType); List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
if (CollUtil.isNotEmpty(dictDatas)) { if (CollUtil.isNotEmpty(dictDatas)) {
return dictDatas; return dictDatas;
} }
dictDatas = dictDataMapper.selectList(new LambdaQueryWrapper<SysDictData>() dictDatas = dictDataMapper.selectDictDataByType(dictType);
.eq(SysDictData::getStatus, 0) if (CollUtil.isNotEmpty(dictDatas)) {
.eq(SysDictData::getDictType, dictType) DictUtils.setDictCache(dictType, dictDatas);
.orderByAsc(SysDictData::getDictSort)); return dictDatas;
if (CollUtil.isNotEmpty(dictDatas)) { }
DictUtils.setDictCache(dictType, dictDatas); return null;
return dictDatas; }
}
return null;
}
/** /**
* 根据字典类型ID查询信息 * 根据字典类型ID查询信息
* *
* @param dictId 字典类型ID * @param dictId 字典类型ID
* @return 字典类型 * @return 字典类型
*/ */
@Override @Override
public SysDictType selectDictTypeById(Long dictId) { public SysDictType selectDictTypeById(Long dictId) {
return getById(dictId); return getById(dictId);
} }
/** /**
* 根据字典类型查询信息 * 根据字典类型查询信息
* *
* @param dictType 字典类型 * @param dictType 字典类型
* @return 字典类型 * @return 字典类型
*/ */
@Override @Override
public SysDictType selectDictTypeByType(String dictType) { public SysDictType selectDictTypeByType(String dictType) {
return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType)); return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
} }
/** /**
* 批量删除字典类型信息 * 批量删除字典类型信息
* *
* @param dictIds 需要删除的字典ID * @param dictIds 需要删除的字典ID
* @return 结果 * @return 结果
*/ */
@Override @Override
public void deleteDictTypeByIds(Long[] dictIds) { public void deleteDictTypeByIds(Long[] dictIds) {
for (Long dictId : dictIds) { for (Long dictId : dictIds) {
SysDictType dictType = selectDictTypeById(dictId); SysDictType dictType = selectDictTypeById(dictId);
if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>() if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>()
.eq(SysDictData::getDictType, dictType.getDictType())) > 0) { .eq(SysDictData::getDictType, dictType.getDictType())) > 0) {
throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName())); throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
} }
dictTypeMapper.deleteDictTypeById(dictId); dictTypeMapper.deleteById(dictId);
DictUtils.removeDictCache(dictType.getDictType()); DictUtils.removeDictCache(dictType.getDictType());
} }
} }
/** /**
* 加载字典缓存数据 * 加载字典缓存数据
*/ */
public void loadingDictCache() @Override
{ public void loadingDictCache() {
List<SysDictType> dictTypeList = dictTypeMapper.selectDictTypeAll(); List<SysDictType> dictTypeList = list();
for (SysDictType dictType : dictTypeList) for (SysDictType dictType : dictTypeList) {
{ List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType());
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType()); DictUtils.setDictCache(dictType.getDictType(), dictDatas);
DictUtils.setDictCache(dictType.getDictType(), dictDatas); }
} }
}
/** /**
* 清空字典缓存数据 * 清空字典缓存数据
*/ */
public void clearDictCache() @Override
{ public void clearDictCache() {
DictUtils.clearDictCache(); DictUtils.clearDictCache();
} }
/** /**
* 重置字典缓存数据 * 重置字典缓存数据
*/ */
public void resetDictCache() @Override
{ public void resetDictCache() {
clearDictCache(); clearDictCache();
loadingDictCache(); loadingDictCache();
} }
/** /**
* 新增保存字典类型信息 * 新增保存字典类型信息
* *
* @param dict 字典类型信息 * @param dict 字典类型信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int insertDictType(SysDictType dict) { public int insertDictType(SysDictType dict) {
int row = baseMapper.insert(dict); int row = baseMapper.insert(dict);
if (row > 0) { if (row > 0) {
DictUtils.setDictCache(dict.getDictType(), null); DictUtils.setDictCache(dict.getDictType(), null);
} }
return row; return row;
} }
/** /**
* 修改保存字典类型信息 * 修改保存字典类型信息
* @param dict 字典类型信息 *
* @return 结果 * @param dict 字典类型信息
*/ * @return 结果
@Override */
@Transactional @Override
public int updateDictType(SysDictType dict) @Transactional
{ public int updateDictType(SysDictType dict) {
SysDictType oldDict = getById(dict.getDictId()); SysDictType oldDict = getById(dict.getDictId());
dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>() dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>()
.set(SysDictData::getDictType, dict.getDictType()) .set(SysDictData::getDictType, dict.getDictType())
.eq(SysDictData::getDictType, oldDict.getDictType())); .eq(SysDictData::getDictType, oldDict.getDictType()));
int row = baseMapper.updateById(dict); int row = baseMapper.updateById(dict);
if (row > 0) if (row > 0) {
{ List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType()); DictUtils.setDictCache(dict.getDictType(), dictDatas);
DictUtils.setDictCache(dict.getDictType(), dictDatas); }
} return row;
return row; }
}
/** /**
* 校验字典类型称是否唯一 * 校验字典类型称是否唯一
* *
* @param dict 字典类型 * @param dict 字典类型
* @return 结果 * @return 结果
*/ */
@Override @Override
public String checkDictTypeUnique(SysDictType dict) { public String checkDictTypeUnique(SysDictType dict) {
Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId(); Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>() SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>()
.eq(SysDictType::getDictType, dict.getDictType()) .eq(SysDictType::getDictType, dict.getDictType())
.last("limit 1")); .last("limit 1"));
if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) { if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
} }
return UserConstants.UNIQUE; return UserConstants.UNIQUE;
} }
} }