diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java b/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
index 7f09d7c7..3d8971d6 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysDictDataMapper.java
@@ -1,8 +1,11 @@
 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.page.BaseMapperPlus;
 
+import java.util.List;
+
 /**
  * 字典表 数据层
  *
@@ -10,4 +13,11 @@ import com.ruoyi.common.core.page.BaseMapperPlus;
  */
 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));
+	}
 }
diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
index 721ce598..2376d8b5 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
@@ -20,7 +20,6 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.PostConstruct;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -37,191 +36,187 @@ public class SysConfigServiceImpl extends ServiceImpl<SysConfigMapper, SysConfig
 	private SysConfigMapper configMapper;
 
 	@Autowired
-    private RedisCache redisCache;
+	private RedisCache redisCache;
 
-    /**
-     * 项目启动时，初始化参数到缓存
-     */
-    @PostConstruct
-    public void init() {
-        loadingConfigCache();
-    }
+	/**
+	 * 项目启动时，初始化参数到缓存
+	 */
+	@PostConstruct
+	public void init() {
+		loadingConfigCache();
+	}
 
-    @Override
-    public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) {
-        Map<String, Object> params = config.getParams();
-        LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
-                .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
-                .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
-                .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
-                .apply(Validator.isNotEmpty(params.get("beginTime")),
-                        "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
-                        params.get("beginTime"))
-                .apply(Validator.isNotEmpty(params.get("endTime")),
-                        "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
-                        params.get("endTime"));
-        return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
-    }
+	@Override
+	public TableDataInfo<SysConfig> selectPageConfigList(SysConfig config) {
+		Map<String, Object> params = config.getParams();
+		LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
+			.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
+			.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
+			.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
+			.apply(Validator.isNotEmpty(params.get("beginTime")),
+				"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
+				params.get("beginTime"))
+			.apply(Validator.isNotEmpty(params.get("endTime")),
+				"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
+				params.get("endTime"));
+		return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
+	}
 
-    /**
-     * 查询参数配置信息
-     *
-     * @param configId 参数配置ID
-     * @return 参数配置信息
-     */
-    @Override
-    @DataSource(DataSourceType.MASTER)
-    public SysConfig selectConfigById(Long configId) {
-        return baseMapper.selectById(configId);
-    }
+	/**
+	 * 查询参数配置信息
+	 *
+	 * @param configId 参数配置ID
+	 * @return 参数配置信息
+	 */
+	@Override
+	@DataSource(DataSourceType.MASTER)
+	public SysConfig selectConfigById(Long configId) {
+		return baseMapper.selectById(configId);
+	}
 
-    /**
-     * 根据键名查询参数配置信息
-     *
-     * @param configKey 参数key
-     * @return 参数键值
-     */
-    @Override
-    public String selectConfigByKey(String configKey) {
-        String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey)));
-        if (Validator.isNotEmpty(configValue)) {
-            return configValue;
-        }
-        SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>()
-                .eq(SysConfig::getConfigKey, configKey));
-        if (Validator.isNotNull(retConfig)) {
-            redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
-            return retConfig.getConfigValue();
-        }
-        return StrUtil.EMPTY;
-    }
+	/**
+	 * 根据键名查询参数配置信息
+	 *
+	 * @param configKey 参数key
+	 * @return 参数键值
+	 */
+	@Override
+	public String selectConfigByKey(String configKey) {
+		String configValue = Convert.toStr(redisCache.getCacheObject(getCacheKey(configKey)));
+		if (Validator.isNotEmpty(configValue)) {
+			return configValue;
+		}
+		SysConfig retConfig = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>()
+			.eq(SysConfig::getConfigKey, configKey));
+		if (Validator.isNotNull(retConfig)) {
+			redisCache.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
+			return retConfig.getConfigValue();
+		}
+		return StrUtil.EMPTY;
+	}
 
-    /**
-     * 查询参数配置列表
-     *
-     * @param config 参数配置信息
-     * @return 参数配置集合
-     */
-    @Override
-    public List<SysConfig> selectConfigList(SysConfig config) {
-        Map<String, Object> params = config.getParams();
-        LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
-                .like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
-                .eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
-                .like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
-                .apply(Validator.isNotEmpty(params.get("beginTime")),
-                        "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
-                        params.get("beginTime"))
-                .apply(Validator.isNotEmpty(params.get("endTime")),
-                        "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
-                        params.get("endTime"));
-        return baseMapper.selectList(lqw);
-    }
+	/**
+	 * 查询参数配置列表
+	 *
+	 * @param config 参数配置信息
+	 * @return 参数配置集合
+	 */
+	@Override
+	public List<SysConfig> selectConfigList(SysConfig config) {
+		Map<String, Object> params = config.getParams();
+		LambdaQueryWrapper<SysConfig> lqw = new LambdaQueryWrapper<SysConfig>()
+			.like(StrUtil.isNotBlank(config.getConfigName()), SysConfig::getConfigName, config.getConfigName())
+			.eq(StrUtil.isNotBlank(config.getConfigType()), SysConfig::getConfigType, config.getConfigType())
+			.like(StrUtil.isNotBlank(config.getConfigKey()), SysConfig::getConfigKey, config.getConfigKey())
+			.apply(Validator.isNotEmpty(params.get("beginTime")),
+				"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
+				params.get("beginTime"))
+			.apply(Validator.isNotEmpty(params.get("endTime")),
+				"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
+				params.get("endTime"));
+		return baseMapper.selectList(lqw);
+	}
 
-    /**
-     * 新增参数配置
-     *
-     * @param config 参数配置信息
-     * @return 结果
-     */
-    @Override
-    public int insertConfig(SysConfig config) {
-        int row = baseMapper.insert(config);
-        if (row > 0) {
-            redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
-        }
-        return row;
-    }
+	/**
+	 * 新增参数配置
+	 *
+	 * @param config 参数配置信息
+	 * @return 结果
+	 */
+	@Override
+	public int insertConfig(SysConfig config) {
+		int row = baseMapper.insert(config);
+		if (row > 0) {
+			redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
+		}
+		return row;
+	}
 
-    /**
-     * 修改参数配置
-     *
-     * @param config 参数配置信息
-     * @return 结果
-     */
-    @Override
-    public int updateConfig(SysConfig config) {
-        int row = baseMapper.updateById(config);
-        if (row > 0) {
-            redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
-        }
-        return row;
-    }
+	/**
+	 * 修改参数配置
+	 *
+	 * @param config 参数配置信息
+	 * @return 结果
+	 */
+	@Override
+	public int updateConfig(SysConfig config) {
+		int row = baseMapper.updateById(config);
+		if (row > 0) {
+			redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
+		}
+		return row;
+	}
 
-    /**
-     * 批量删除参数信息
-     *
-     * @param configIds 需要删除的参数ID
-     * @return 结果
-     */
-    @Override
-    public void deleteConfigByIds(Long[] configIds) {
-        for (Long configId : configIds) {
-            SysConfig config = selectConfigById(configId);
-            if (StrUtil.equals(UserConstants.YES, config.getConfigType())) {
-                throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
-            }
-            configMapper.deleteConfigById(configId);
-            redisCache.deleteObject(getCacheKey(config.getConfigKey()));
-        }
-    }
+	/**
+	 * 批量删除参数信息
+	 *
+	 * @param configIds 需要删除的参数ID
+	 * @return 结果
+	 */
+	@Override
+	public void deleteConfigByIds(Long[] configIds) {
+		for (Long configId : configIds) {
+			SysConfig config = selectConfigById(configId);
+			if (StrUtil.equals(UserConstants.YES, config.getConfigType())) {
+				throw new CustomException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
+			}
+			configMapper.deleteById(configId);
+			redisCache.deleteObject(getCacheKey(config.getConfigKey()));
+		}
+	}
 
-    /**
-     * 加载参数缓存数据
-     */
-    @Override
-    public void loadingConfigCache()
-    {
-        List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig());
-        for (SysConfig config : configsList)
-        {
-            redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
-        }
-    }
+	/**
+	 * 加载参数缓存数据
+	 */
+	@Override
+	public void loadingConfigCache() {
+		List<SysConfig> configsList = selectConfigList(new SysConfig());
+		for (SysConfig config : configsList) {
+			redisCache.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
+		}
+	}
 
-    /**
-     * 清空参数缓存数据
-     */
-    @Override
-    public void clearConfigCache()
-    {
-        Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*");
-        redisCache.deleteObject(keys);
-    }
+	/**
+	 * 清空参数缓存数据
+	 */
+	@Override
+	public void clearConfigCache() {
+		Collection<String> keys = redisCache.keys(Constants.SYS_CONFIG_KEY + "*");
+		redisCache.deleteObject(keys);
+	}
 
-    /**
-     * 重置参数缓存数据
-     */
-    @Override
-    public void resetConfigCache()
-    {
-        clearConfigCache();
-        loadingConfigCache();
-    }
+	/**
+	 * 重置参数缓存数据
+	 */
+	@Override
+	public void resetConfigCache() {
+		clearConfigCache();
+		loadingConfigCache();
+	}
 
-    /**
-     * 校验参数键名是否唯一
-     *
-     * @param config 参数配置信息
-     * @return 结果
-     */
-    @Override
-    public String checkConfigKeyUnique(SysConfig config) {
-        Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId();
-        SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey()));
-        if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
-            return UserConstants.NOT_UNIQUE;
-        }
-        return UserConstants.UNIQUE;
-    }
+	/**
+	 * 校验参数键名是否唯一
+	 *
+	 * @param config 参数配置信息
+	 * @return 结果
+	 */
+	@Override
+	public String checkConfigKeyUnique(SysConfig config) {
+		Long configId = Validator.isNull(config.getConfigId()) ? -1L : config.getConfigId();
+		SysConfig info = baseMapper.selectOne(new LambdaQueryWrapper<SysConfig>().eq(SysConfig::getConfigKey, config.getConfigKey()));
+		if (Validator.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
+			return UserConstants.NOT_UNIQUE;
+		}
+		return UserConstants.UNIQUE;
+	}
 
-    /**
-     * 设置cache key
-     *
-     * @param configKey 参数键
-     * @return 缓存键key
-     */
-    private String getCacheKey(String configKey) {
-        return Constants.SYS_CONFIG_KEY + configKey;
-    }
+	/**
+	 * 设置cache key
+	 *
+	 * @param configKey 参数键
+	 * @return 缓存键key
+	 */
+	private String getCacheKey(String configKey) {
+		return Constants.SYS_CONFIG_KEY + configKey;
+	}
 }
diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
index 8e29db65..70385659 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
@@ -11,7 +11,6 @@ import com.ruoyi.system.mapper.SysDictDataMapper;
 import com.ruoyi.system.service.ISysDictDataService;
 import org.springframework.stereotype.Service;
 
-import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -22,112 +21,103 @@ import java.util.List;
 @Service
 public class SysDictDataServiceImpl extends ServiceImpl<SysDictDataMapper, SysDictData> implements ISysDictDataService {
 
-	@Autowired
-	private SysDictDataMapper dictDataMapper;
+	@Override
+	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())
-                .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));
-    }
+	/**
+	 * 根据条件分页查询字典数据
+	 *
+	 * @param dictData 字典数据信息
+	 * @return 字典数据集合信息
+	 */
+	@Override
+	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 字典数据信息
-     * @return 字典数据集合信息
-     */
-    @Override
-    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 dictType  字典类型
+	 * @param dictValue 字典键值
+	 * @return 字典标签
+	 */
+	@Override
+	public String selectDictLabel(String dictType, String dictValue) {
+		return getOne(new LambdaQueryWrapper<SysDictData>()
+			.select(SysDictData::getDictLabel)
+			.eq(SysDictData::getDictType, dictType)
+			.eq(SysDictData::getDictValue, dictValue))
+			.getDictLabel();
+	}
 
-    /**
-     * 根据字典类型和字典键值查询字典数据信息
-     *
-     * @param dictType  字典类型
-     * @param dictValue 字典键值
-     * @return 字典标签
-     */
-    @Override
-    public String selectDictLabel(String dictType, String dictValue) {
-        return getOne(new LambdaQueryWrapper<SysDictData>()
-                .select(SysDictData::getDictLabel)
-                .eq(SysDictData::getDictType, dictType)
-                .eq(SysDictData::getDictValue, dictValue))
-                .getDictLabel();
-    }
+	/**
+	 * 根据字典数据ID查询信息
+	 *
+	 * @param dictCode 字典数据ID
+	 * @return 字典数据
+	 */
+	@Override
+	public SysDictData selectDictDataById(Long dictCode) {
+		return getById(dictCode);
+	}
 
-    /**
-     * 根据字典数据ID查询信息
-     *
-     * @param dictCode 字典数据ID
-     * @return 字典数据
-     */
-    @Override
-    public SysDictData selectDictDataById(Long dictCode) {
-        return getById(dictCode);
-    }
+	/**
+	 * 批量删除字典数据信息
+	 *
+	 * @param dictCodes 需要删除的字典数据ID
+	 * @return 结果
+	 */
+	@Override
+	public void deleteDictDataByIds(Long[] dictCodes) {
+		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
-     * @return 结果
-     */
-    @Override
-    public void deleteDictDataByIds(Long[] dictCodes)
-    {
-        for (Long dictCode : dictCodes)
-        {
-            SysDictData data = selectDictDataById(dictCode);
-            dictDataMapper.deleteDictDataById(dictCode);
-            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
-            DictUtils.setDictCache(data.getDictType(), dictDatas);
-        }
-    }
+	/**
+	 * 新增保存字典数据信息
+	 *
+	 * @param data 字典数据信息
+	 * @return 结果
+	 */
+	@Override
+	public int insertDictData(SysDictData data) {
+		int row = baseMapper.insert(data);
+		if (row > 0) {
+			List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
+			DictUtils.setDictCache(data.getDictType(), dictDatas);
+		}
+		return row;
+	}
 
-    /**
-     * 新增保存字典数据信息
-     *
-     * @param data 字典数据信息
-     * @return 结果
-     */
-    @Override
-    public int insertDictData(SysDictData data)
-    {
-        int row = baseMapper.insert(data);
-        if (row > 0)
-        {
-            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
-            DictUtils.setDictCache(data.getDictType(), dictDatas);
-        }
-        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;
-    }
+	/**
+	 * 修改保存字典数据信息
+	 *
+	 * @param data 字典数据信息
+	 * @return 结果
+	 */
+	@Override
+	public int updateDictData(SysDictData data) {
+		int row = baseMapper.updateById(data);
+		if (row > 0) {
+			List<SysDictData> dictDatas = baseMapper.selectDictDataByType(data.getDictType());
+			DictUtils.setDictCache(data.getDictType(), dictDatas);
+		}
+		return row;
+	}
 }
diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
index 04e66167..79a4036e 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
@@ -21,7 +21,6 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.PostConstruct;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
@@ -36,210 +35,205 @@ public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDi
 	@Autowired
 	private SysDictTypeMapper dictTypeMapper;
 
-    @Autowired
-    private SysDictDataMapper dictDataMapper;
+	@Autowired
+	private SysDictDataMapper dictDataMapper;
 
-    /**
-     * 项目启动时，初始化字典到缓存
-     */
-    @PostConstruct
-    public void init() {
-        loadingDictCache();
-    }
+	/**
+	 * 项目启动时，初始化字典到缓存
+	 */
+	@PostConstruct
+	public void init() {
+		loadingDictCache();
+	}
 
-    @Override
-    public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) {
-        Map<String, Object> params = dictType.getParams();
-        LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
-                .like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
-                .eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
-                .like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
-                .apply(Validator.isNotEmpty(params.get("beginTime")),
-                        "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
-                        params.get("beginTime"))
-                .apply(Validator.isNotEmpty(params.get("endTime")),
-                        "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
-                        params.get("endTime"));
-        return PageUtils.buildDataInfo(page(PageUtils.buildPage(),lqw));
-    }
+	@Override
+	public TableDataInfo<SysDictType> selectPageDictTypeList(SysDictType dictType) {
+		Map<String, Object> params = dictType.getParams();
+		LambdaQueryWrapper<SysDictType> lqw = new LambdaQueryWrapper<SysDictType>()
+			.like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
+			.eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
+			.like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
+			.apply(Validator.isNotEmpty(params.get("beginTime")),
+				"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
+				params.get("beginTime"))
+			.apply(Validator.isNotEmpty(params.get("endTime")),
+				"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
+				params.get("endTime"));
+		return PageUtils.buildDataInfo(page(PageUtils.buildPage(), lqw));
+	}
 
-    /**
-     * 根据条件分页查询字典类型
-     *
-     * @param dictType 字典类型信息
-     * @return 字典类型集合信息
-     */
-    @Override
-    public List<SysDictType> selectDictTypeList(SysDictType dictType) {
-        Map<String, Object> params = dictType.getParams();
-        return list(new LambdaQueryWrapper<SysDictType>()
-                .like(StrUtil.isNotBlank(dictType.getDictName()),SysDictType::getDictName, dictType.getDictName())
-                .eq(StrUtil.isNotBlank(dictType.getStatus()),SysDictType::getStatus, dictType.getStatus())
-                .like(StrUtil.isNotBlank(dictType.getDictType()),SysDictType::getDictType, dictType.getDictType())
-                .apply(Validator.isNotEmpty(params.get("beginTime")),
-                        "date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
-                        params.get("beginTime"))
-                .apply(Validator.isNotEmpty(params.get("endTime")),
-                        "date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
-                        params.get("endTime")));
-    }
+	/**
+	 * 根据条件分页查询字典类型
+	 *
+	 * @param dictType 字典类型信息
+	 * @return 字典类型集合信息
+	 */
+	@Override
+	public List<SysDictType> selectDictTypeList(SysDictType dictType) {
+		Map<String, Object> params = dictType.getParams();
+		return list(new LambdaQueryWrapper<SysDictType>()
+			.like(StrUtil.isNotBlank(dictType.getDictName()), SysDictType::getDictName, dictType.getDictName())
+			.eq(StrUtil.isNotBlank(dictType.getStatus()), SysDictType::getStatus, dictType.getStatus())
+			.like(StrUtil.isNotBlank(dictType.getDictType()), SysDictType::getDictType, dictType.getDictType())
+			.apply(Validator.isNotEmpty(params.get("beginTime")),
+				"date_format(create_time,'%y%m%d') >= date_format({0},'%y%m%d')",
+				params.get("beginTime"))
+			.apply(Validator.isNotEmpty(params.get("endTime")),
+				"date_format(create_time,'%y%m%d') <= date_format({0},'%y%m%d')",
+				params.get("endTime")));
+	}
 
-    /**
-     * 根据所有字典类型
-     *
-     * @return 字典类型集合信息
-     */
-    @Override
-    public List<SysDictType> selectDictTypeAll() {
-        return list();
-    }
+	/**
+	 * 根据所有字典类型
+	 *
+	 * @return 字典类型集合信息
+	 */
+	@Override
+	public List<SysDictType> selectDictTypeAll() {
+		return list();
+	}
 
-    /**
-     * 根据字典类型查询字典数据
-     *
-     * @param dictType 字典类型
-     * @return 字典数据集合信息
-     */
-    @Override
-    public List<SysDictData> selectDictDataByType(String dictType) {
-        List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
-        if (CollUtil.isNotEmpty(dictDatas)) {
-            return dictDatas;
-        }
-        dictDatas = dictDataMapper.selectList(new LambdaQueryWrapper<SysDictData>()
-                .eq(SysDictData::getStatus, 0)
-                .eq(SysDictData::getDictType, dictType)
-                .orderByAsc(SysDictData::getDictSort));
-        if (CollUtil.isNotEmpty(dictDatas)) {
-            DictUtils.setDictCache(dictType, dictDatas);
-            return dictDatas;
-        }
-        return null;
-    }
+	/**
+	 * 根据字典类型查询字典数据
+	 *
+	 * @param dictType 字典类型
+	 * @return 字典数据集合信息
+	 */
+	@Override
+	public List<SysDictData> selectDictDataByType(String dictType) {
+		List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
+		if (CollUtil.isNotEmpty(dictDatas)) {
+			return dictDatas;
+		}
+		dictDatas = dictDataMapper.selectDictDataByType(dictType);
+		if (CollUtil.isNotEmpty(dictDatas)) {
+			DictUtils.setDictCache(dictType, dictDatas);
+			return dictDatas;
+		}
+		return null;
+	}
 
-    /**
-     * 根据字典类型ID查询信息
-     *
-     * @param dictId 字典类型ID
-     * @return 字典类型
-     */
-    @Override
-    public SysDictType selectDictTypeById(Long dictId) {
-        return getById(dictId);
-    }
+	/**
+	 * 根据字典类型ID查询信息
+	 *
+	 * @param dictId 字典类型ID
+	 * @return 字典类型
+	 */
+	@Override
+	public SysDictType selectDictTypeById(Long dictId) {
+		return getById(dictId);
+	}
 
-    /**
-     * 根据字典类型查询信息
-     *
-     * @param dictType 字典类型
-     * @return 字典类型
-     */
-    @Override
-    public SysDictType selectDictTypeByType(String dictType) {
-        return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
-    }
+	/**
+	 * 根据字典类型查询信息
+	 *
+	 * @param dictType 字典类型
+	 * @return 字典类型
+	 */
+	@Override
+	public SysDictType selectDictTypeByType(String dictType) {
+		return getOne(new LambdaQueryWrapper<SysDictType>().eq(SysDictType::getDictType, dictType));
+	}
 
-    /**
-     * 批量删除字典类型信息
-     *
-     * @param dictIds 需要删除的字典ID
-     * @return 结果
-     */
-    @Override
-    public void deleteDictTypeByIds(Long[] dictIds) {
-        for (Long dictId : dictIds) {
-            SysDictType dictType = selectDictTypeById(dictId);
-            if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>()
-                    .eq(SysDictData::getDictType, dictType.getDictType())) > 0) {
-                throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
-            }
-            dictTypeMapper.deleteDictTypeById(dictId);
-            DictUtils.removeDictCache(dictType.getDictType());
-        }
-    }
+	/**
+	 * 批量删除字典类型信息
+	 *
+	 * @param dictIds 需要删除的字典ID
+	 * @return 结果
+	 */
+	@Override
+	public void deleteDictTypeByIds(Long[] dictIds) {
+		for (Long dictId : dictIds) {
+			SysDictType dictType = selectDictTypeById(dictId);
+			if (dictDataMapper.selectCount(new LambdaQueryWrapper<SysDictData>()
+				.eq(SysDictData::getDictType, dictType.getDictType())) > 0) {
+				throw new CustomException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
+			}
+			dictTypeMapper.deleteById(dictId);
+			DictUtils.removeDictCache(dictType.getDictType());
+		}
+	}
 
-    /**
-     * 加载字典缓存数据
-     */
-    public void loadingDictCache()
-    {
-        List<SysDictType> dictTypeList = dictTypeMapper.selectDictTypeAll();
-        for (SysDictType dictType : dictTypeList)
-        {
-            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType());
-            DictUtils.setDictCache(dictType.getDictType(), dictDatas);
-        }
-    }
+	/**
+	 * 加载字典缓存数据
+	 */
+	@Override
+	public void loadingDictCache() {
+		List<SysDictType> dictTypeList = list();
+		for (SysDictType dictType : dictTypeList) {
+			List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType());
+			DictUtils.setDictCache(dictType.getDictType(), dictDatas);
+		}
+	}
 
-    /**
-     * 清空字典缓存数据
-     */
-    public void clearDictCache()
-    {
-        DictUtils.clearDictCache();
-    }
+	/**
+	 * 清空字典缓存数据
+	 */
+	@Override
+	public void clearDictCache() {
+		DictUtils.clearDictCache();
+	}
 
-    /**
-     * 重置字典缓存数据
-     */
-    public void resetDictCache()
-    {
-        clearDictCache();
-        loadingDictCache();
-    }
+	/**
+	 * 重置字典缓存数据
+	 */
+	@Override
+	public void resetDictCache() {
+		clearDictCache();
+		loadingDictCache();
+	}
 
-    /**
-     * 新增保存字典类型信息
-     *
-     * @param dict 字典类型信息
-     * @return 结果
-     */
-    @Override
-    public int insertDictType(SysDictType dict) {
-        int row = baseMapper.insert(dict);
-        if (row > 0) {
+	/**
+	 * 新增保存字典类型信息
+	 *
+	 * @param dict 字典类型信息
+	 * @return 结果
+	 */
+	@Override
+	public int insertDictType(SysDictType dict) {
+		int row = baseMapper.insert(dict);
+		if (row > 0) {
 			DictUtils.setDictCache(dict.getDictType(), null);
-        }
-        return row;
-    }
+		}
+		return row;
+	}
 
-    /**
-     * 修改保存字典类型信息
-     * @param dict 字典类型信息
-     * @return 结果
-     */
-    @Override
-    @Transactional
-    public int updateDictType(SysDictType dict)
-    {
+	/**
+	 * 修改保存字典类型信息
+	 *
+	 * @param dict 字典类型信息
+	 * @return 结果
+	 */
+	@Override
+	@Transactional
+	public int updateDictType(SysDictType dict) {
 		SysDictType oldDict = getById(dict.getDictId());
 		dictDataMapper.update(null, new LambdaUpdateWrapper<SysDictData>()
 			.set(SysDictData::getDictType, dict.getDictType())
 			.eq(SysDictData::getDictType, oldDict.getDictType()));
 		int row = baseMapper.updateById(dict);
-        if (row > 0)
-        {
-            List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
-            DictUtils.setDictCache(dict.getDictType(), dictDatas);
-        }
-        return row;
-    }
+		if (row > 0) {
+			List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
+			DictUtils.setDictCache(dict.getDictType(), dictDatas);
+		}
+		return row;
+	}
 
-    /**
-     * 校验字典类型称是否唯一
-     *
-     * @param dict 字典类型
-     * @return 结果
-     */
-    @Override
-    public String checkDictTypeUnique(SysDictType dict) {
-        Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId();
-        SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>()
-                .eq(SysDictType::getDictType, dict.getDictType())
-                .last("limit 1"));
-        if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
-            return UserConstants.NOT_UNIQUE;
-        }
-        return UserConstants.UNIQUE;
-    }
+	/**
+	 * 校验字典类型称是否唯一
+	 *
+	 * @param dict 字典类型
+	 * @return 结果
+	 */
+	@Override
+	public String checkDictTypeUnique(SysDictType dict) {
+		Long dictId = Validator.isNull(dict.getDictId()) ? -1L : dict.getDictId();
+		SysDictType dictType = getOne(new LambdaQueryWrapper<SysDictType>()
+			.eq(SysDictType::getDictType, dict.getDictType())
+			.last("limit 1"));
+		if (Validator.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
+			return UserConstants.NOT_UNIQUE;
+		}
+		return UserConstants.UNIQUE;
+	}
 }