字典翻譯

最近比較煩，電腦壞了。把以前的好東西備份一下。
1.字典翻譯

表結構

CREATE TABLE `t_sys_dict` (
  `dict_id` varchar(20) NOT NULL,
  `sys_code` varchar(20) NOT NULL DEFAULT 'xiong' COMMENT '系統代碼',
  `dict_code` varchar(50) NOT NULL COMMENT '數據字典鍵',
  `dict_value` varchar(200) NOT NULL COMMENT '數據字典值',
  `dict_remark` varchar(50) DEFAULT NULL COMMENT '數據字典描述',
  `create_time` datetime DEFAULT NULL,
  PRIMARY KEY (`dict_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='數據字典表';

INSERT INTO `t_sys_dict` VALUES ('10', 'XYC', 'orderStatus', 'WAIT_BUYER_CONFIRM_GOODS', '等待買家確認收貨,即:賣家已發貨', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('11', 'XYC', 'orderStatus', 'TRADE_BUYER_SIGNED', '買家已簽收,貨到付款專用', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('12', 'XYC', 'orderStatus', 'TRADE_FINISHED', '交易成功', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('13', 'XYC', 'orderStatus', 'TRADE_CLOSED', '交易關閉', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('14', 'XYC', 'orderStatus', 'TRADE_CLOSED_BY_TAOBAO', '交易被淘寶關閉', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('7', 'XYC', 'orderStatus', 'TRADE_NO_CREATE_PAY', '沒有創建支付寶交易', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('8', 'XYC', 'orderStatus', 'WAIT_BUYER_PAY', '等待買家付款', '2019-04-19 20:38:32');
INSERT INTO `t_sys_dict` VALUES ('9', 'XYC', 'orderStatus', 'WAIT_SELLER_SEND_GOODS', '等待賣家發貨,即:買家已付款', '2019-04-19 20:38:32');

字典註解類

package com.xyc.cloud.utils;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Dict {
	public abstract String dictCode() default "";
}

需要翻譯實體類字段

	/**
	 * 退款對應的訂單交易狀態。 可選值
	 * TRADE_NO_CREATE_PAY(沒有創建支付寶交易) 
	 * WAIT_BUYER_PAY(等待買家付款)
	 * WAIT_SELLER_SEND_GOODS(等待賣家發貨,即:買家已付款)
	 * WAIT_BUYER_CONFIRM_GOODS(等待買家確認收貨,即:賣家已發貨) 
	 * TRADE_BUYER_SIGNED(買家已簽收,貨到付款專用)
	 * TRADE_FINISHED(交易成功) 
	 * TRADE_CLOSED(交易關閉) 
	 * TRADE_CLOSED_BY_TAOBAO(交易被淘寶關閉)
	 * ALL_WAIT_PAY(包含：WAIT_BUYER_PAY、TRADE_NO_CREATE_PAY)
	 * ALL_CLOSED(包含：TRADE_CLOSED、TRADE_CLOSED_BY_TAOBAO)
	 */
	@Dict(dictCode="orderStatus")
	@ApiModelProperty(value = "退款對應的訂單交易狀態")
	private String orderStatus;

執行翻譯

		List<Map<String, Object>>  map = sysDictService.translateToMapList(list); //list 你的數據庫查詢結果集

最終結果

元數據翻譯數據

2.下面是字典翻譯的CRUD 和具體內部轉換

mode類

package com.xiong.cloud.bean;

import java.util.Date;

import org.apache.commons.lang3.builder.ReflectionToStringBuilder;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.honghu.cloud.common.utils.mybatis.IModel;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

@ApiModel("數據字典表")
public class SysDict implements IModel {

	private static final long serialVersionUID = 1L;

	public String toString() {
		return ReflectionToStringBuilder.toString(this);
	}

	@ApiModelProperty(value = "")
	private String dictId;

	/**
	 * 數據字典鍵
	 */
	@ApiModelProperty(value = "數據字典鍵")
	private String dictCode;

	/**
	 * 數據字典值
	 */
	@ApiModelProperty(value = "數據字典值")
	private String dictValue;

	
	/**
	 * 數據字典描述
	 */
	@ApiModelProperty(value = "數據字典描述")
	private String dictRemark;

	@ApiModelProperty(value = "")
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
	private Date createTime;

	public String getDictId() {
		return dictId;
	}

	public void setDictId(String dictId) {
		this.dictId = dictId;
	}

	/**
	 * 獲取 數據字典鍵
	 */
	public String getDictCode() {
		return dictCode;
	}

	/**
	 * 設置 數據字典鍵
	 */
	public void setDictCode(String dictCode) {
		this.dictCode = dictCode;
	}

	/**
	 * 獲取 數據字典值
	 */
	public String getDictValue() {
		return dictValue;
	}

	/**
	 * 設置 數據字典值
	 */
	public void setDictValue(String dictValue) {
		this.dictValue = dictValue;
	}

	/**
	 * 獲取 數據字典描述
	 */
	public String getDictRemark() {
		return dictRemark;
	}

	/**
	 * 設置 數據字典描述
	 */
	public void setDictRemark(String dictRemark) {
		this.dictRemark = dictRemark;
	}

	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}

}

mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xyc.cloud.dao.ISysDictDao">
<resultMap id="BaseResultMap"  type="com.xyc.cloud.bean.SysDict" >
	<result column="dict_id" property="dictId" jdbcType="VARCHAR" />
	<result column="dict_code" property="dictCode" jdbcType="VARCHAR" />
	<result column="dict_value" property="dictValue" jdbcType="VARCHAR" />
	<result column="dict_remark" property="dictRemark" jdbcType="VARCHAR" />
	<result column="create_time" property="createTime" jdbcType="TIMESTAMP" />
</resultMap> 
<sql id="Criteria_Where_Clause"> 
	<where> 
		<if test="params.dictId!=null">
			 and dict_id=#{params.dictId}
		</if>
		<if test="params.dictCode!=null">
			 and dict_code=#{params.dictCode}
		</if>
		<if test="params.dictValue!=null">
			 and dict_value=#{params.dictValue}
		</if>
		<if test="params.dictRemark!=null">
			 and dict_remark=#{params.dictRemark}
		</if>
		<if test="params.createTime!=null">
			 and create_time=#{params.createTime}
		</if>
	</where> 
</sql> 
<sql id="Base_Column_List">
  dict_id,dict_code,dict_value,dict_remark,create_time
</sql> 
<select id="queryPage" resultMap="BaseResultMap" parameterType="com.honghu.cloud.common.utils.mybatis.Criteria"> 
	select 
	<include refid="Base_Column_List" />
	from t_sys_dict
	<if test="params != null"> 
		<include refid="Criteria_Where_Clause" /> 
	</if> 
	<if test="orderBy!=null"> 
		order by ${orderBy} 
	</if> 
</select> 
<select id="queryList" resultMap="BaseResultMap" parameterType="com.honghu.cloud.common.utils.mybatis.Criteria"> 
	select 
	<include refid="Base_Column_List" />
	from t_sys_dict
	<if test="params != null"> 
		<include refid="Criteria_Where_Clause" /> 
	</if> 
	<if test="orderBy!=null"> 
		order by ${orderBy} 
	</if> 
</select> 
<select id="queryPageCount" resultType="java.lang.Integer" parameterType="com.honghu.cloud.common.utils.mybatis.Criteria"> 
	select count(1) from t_sys_dict 
	<if test="params != null"> 
		<include refid="Criteria_Where_Clause" /> 
	</if> 
</select> 
<select id="queryEntityById" resultMap="BaseResultMap" parameterType="java.lang.String">
	select 
	<include refid="Base_Column_List" />
	from t_sys_dict	where dict_id = #{dictId}
</select>
<insert id="insert" parameterType="com.xyc.cloud.bean.SysDict"> 
	insert into t_sys_dict
	<trim prefix="(" suffix=")" suffixOverrides=",">
		<if test="dictId != null"> 
			dict_id,
		</if>
		<if test="dictCode != null"> 
			dict_code,
		</if>
		<if test="dictValue != null"> 
			dict_value,
		</if>
		<if test="dictRemark != null"> 
			dict_remark,
		</if>
		<if test="createTime != null"> 
			create_time,
		</if>
	</trim>
	values
	<trim prefix="(" suffix=")" suffixOverrides=",">
	<if test="dictId != null"> 
		#{dictId},
	</if>
	<if test="dictCode != null"> 
		#{dictCode},
	</if>
	<if test="dictValue != null"> 
		#{dictValue},
	</if>
	<if test="dictRemark != null"> 
		#{dictRemark},
	</if>
	<if test="createTime != null"> 
		#{createTime},
	</if>
	</trim>
</insert>
<insert id="insertBatch" parameterType="java.util.List"> 
	insert into t_sys_dict
	<trim prefix="(" suffix=")" suffixOverrides=",">
			dict_id,dict_code,dict_value,dict_remark,create_time
	</trim>
	values
	<foreach collection="list" item="item" separator=",">
		<trim prefix="(" suffix=")" suffixOverrides=",">
			#{item.dictId},#{item.dictCode},#{item.dictValue},#{item.dictRemark},#{item.createTime}
		</trim>
	</foreach>
</insert>
<!--  批量保存 存在更新不存在插入(如果指定一個on duplicate key update子句，並且要插入的行將導致唯一索引或主鍵中的值重複，
則會更新舊行, 對於innodb表，如果a是自動遞增列，則效果不相同。對於自動遞增列，insert語句會增加自動遞增值，但update不會。 )
詳細文檔 https://dev.mysql.com/doc/refman/5.5/en/insert-on-duplicate.html -->
<insert id="insertOrUpdateBatch" parameterType="java.util.List"> 
	<foreach collection="list" item="item" separator=";">
	insert into t_sys_dict
	<trim prefix="(" suffix=")" suffixOverrides=",">
		<if test="item.dictId != null"> 
			dict_id,
		</if>
		<if test="item.dictCode != null"> 
			dict_code,
		</if>
		<if test="item.dictValue != null"> 
			dict_value,
		</if>
		<if test="item.dictRemark != null"> 
			dict_remark,
		</if>
		<if test="item.createTime != null"> 
			create_time,
		</if>
	</trim>
	values
	<trim prefix="(" suffix=")" suffixOverrides=",">
	<if test="item.dictId != null"> 
		#{item.dictId},
	</if>
	<if test="item.dictCode != null"> 
		#{item.dictCode},
	</if>
	<if test="item.dictValue != null"> 
		#{item.dictValue},
	</if>
	<if test="item.dictRemark != null"> 
		#{item.dictRemark},
	</if>
	<if test="item.createTime != null"> 
		#{item.createTime},
	</if>
	</trim>
	ON DUPLICATE KEY UPDATE
	dict_code = #{item.dictCode},dict_value = #{item.dictValue},dict_remark = #{item.dictRemark},create_time = #{item.createTime}
	</foreach>
</insert>
<update id="updateByCriteria" parameterType="com.honghu.cloud.common.utils.mybatis.Criteria">
	update t_sys_dict
	<set>
	<if test="record.dictId != null"> 
		dict_id = #{record.dictId},
	</if>
	<if test="record.dictCode != null"> 
		dict_code = #{record.dictCode},
	</if>
	<if test="record.dictValue != null"> 
		dict_value = #{record.dictValue},
	</if>
	<if test="record.dictRemark != null"> 
		dict_remark = #{record.dictRemark},
	</if>
	<if test="record.createTime != null"> 
		create_time = #{record.createTime},
	</if>
	</set>
	<if test="params != null">
		<include refid="Criteria_Where_Clause" />
	</if>
</update>
<update id="updateBatchByCriteria" parameterType="java.util.List">
	<foreach collection="list" item="params" separator=";">
		update t_sys_dict
		<set>
		<if test="params.dictId != null"> 
			dict_id = #{params.dictId},
		</if>
		<if test="params.dictCode != null"> 
			dict_code = #{params.dictCode},
		</if>
		<if test="params.dictValue != null"> 
			dict_value = #{params.dictValue},
		</if>
		<if test="params.dictRemark != null"> 
			dict_remark = #{params.dictRemark},
		</if>
		<if test="params.createTime != null"> 
			create_time = #{params.createTime},
		</if>
		</set>
		<if test="params != null">
			<where>
				<if test="params.id!=null">
					and id=#{params.id}
				</if>
			</where>
		</if>
	</foreach>
</update>
<delete id="deleteByCriteria" parameterType="com.honghu.cloud.common.utils.mybatis.Criteria">
	delete from t_sys_dict
	<if test="params != null">
		<include refid="Criteria_Where_Clause" />
	</if>
</delete>
<delete id="deleteById" parameterType="java.lang.String">
	delete from t_sys_dict
	where dict_id = #{dictId}
</delete>
<delete id="deleteBatchByIds">
	delete from t_sys_dict
	where apply_id in
	<foreach collection="array" item="id" open="(" close=")" separator=",">
		#{id}
	</foreach>
</delete>
</mapper>

Repository

package com.xyc.cloud.dao;


import java.util.List;
import com.honghu.cloud.common.utils.mybatis.Criteria;
import org.springframework.stereotype.Repository;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import com.xyc.cloud.bean.SysDict;


@Repository
public interface ISysDictDao{

	/**
	* 查詢集合 
	* @param param
	* @return
	*/
	List<SysDict> queryPage(Pagination page , Criteria<SysDict> param);

	
	/**
	* 查詢List集合 
	* @param param
	* @return
	*/
	List<SysDict> queryList(Criteria<SysDict> param);
	
	/**
	* 查詢集合總記錄數 
	* @param param
	* @return
	*/
	Integer queryPageCount(Pagination page , Criteria<SysDict> param);

	/**
	* 查詢實體 
	* @param id
	* @return
	*/
	SysDict queryEntityById(String dictId);

	/**
	* 新增實體 
	* @param record
	* @return
	*/
	Integer insert(SysDict record);

	/**
	* 批量新增實體 
	* @param list
	* @return
	*/
	Integer insertBatch(List<SysDict> list);

	/**
	* 更新實體 
	* @param param
	* @return
	*/
	Integer updateByCriteria(Criteria<SysDict> param);

	/**
	* 批量更新實體 
	* @param list
	* @return
	*/
	Integer updateBatchByCriteria(List<SysDict> list);

	/**
	* 批量保存實體 
	* @param list
	* @return
	*/
	Integer insertOrUpdateBatch(List<SysDict> list);

	/**
	* 刪除實體 
	* @param id
	* @return
	*/
	Integer deleteById(String dictId);

	/**
	* 刪除實體 
	* @param id
	* @return
	*/
	Integer deleteByCriteria(Criteria<SysDict> param);

	/**
	* 刪除實體 
	* @param ids
	* @return
	*/
	Integer deleteBatchByIds(String[] array);



}

Service 

package com.xyc.cloud.service;

import java.util.List;
import java.util.Map;

import com.baomidou.mybatisplus.plugins.Page;
import com.xyc.cloud.bean.SysDict;
import com.honghu.cloud.common.utils.mybatis.Criteria;

public interface ISysDictService {

	/**
	 * 查詢集合
	 * 
	 * @param param
	 * @return
	 */
	Page<SysDict> queryPage(Page<SysDict> page, Criteria<SysDict> param);

	/**
	 * 查詢集合總記錄數
	 * 
	 * @param param
	 * @return
	 */
	Integer queryPageCount(Page<SysDict> page, Criteria<SysDict> param);

	/**
	 * 查詢實體
	 * 
	 * @param id
	 * @return
	 */
	SysDict queryEntityById(String dictId);

	/**
	 * 新增實體
	 * 
	 * @param record
	 * @return
	 */
	String insert(SysDict record);

	/**
	 * 批量新增實體
	 * 
	 * @param list
	 * @return
	 */
	String insertBatch(List<SysDict> list);

	/**
	 * 更新實體
	 * 
	 * @param param
	 * @return
	 */
	String updateByCriteria(Criteria<SysDict> param);

	/**
	 * 批量更新實體
	 * 
	 * @param param
	 * @return
	 */
	String updateBatchByCriteria(List<SysDict> list);

	/**
	 * 批量保存實體
	 * 
	 * @param list
	 * @return
	 */
	String insertOrUpdateBatch(List<SysDict> list);

	/**
	 * 刪除實體
	 * 
	 * @param id
	 * @return
	 */
	String deleteById(String dictId);

	/**
	 * 刪除實體
	 * 
	 * @param model
	 * @return
	 */
	String deleteByCriteria(Criteria<SysDict> param);

	/**
	 * 批量刪除實體
	 * 
	 * @param ids
	 * @return
	 */
	String deleteBatchByIds(String[] ids);

	/**
	 * 數據字典翻譯 ，轉換爲 List <Map> 形式
	 * 
	 * @param data 原始結果集 T爲pojo對像，需要在翻譯字段上加註解 Dict
	 * 
	 * @return 翻譯後結果集
	 * 
	 * @see com.xyc.cloud.utils.Dict
	 */
	<T> List<Map<String, Object>> translateToMapList(List<T> data);

	/**
	 * 數據字典翻譯 ，轉換爲 List <Map> 形式
	 * 
	 * @param data         原始結果集 columnName = value
	 * @param transColumns 需要翻譯的字段 columnName = dictCode
	 * @return 翻譯後結果集
	 */
	List<Map<String, Object>> translateToMapList(List<Map<String, Object>> data, Map<String, String> transColumns);

	/**
	 * 數據字典翻譯 ，轉換爲 Map 形式
	 * 
	 * @param data pojo對像，需要在翻譯字段上加註解 Dict
	 * 
	 * @return 翻譯後結果
	 * 
	 * @see com.xyc.cloud.utils.Dict
	 */
	Map<String, Object> translateToMap(Object obj);

}

impl

package com.xyc.cloud.service.impl;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.commons.lang3.reflect.MethodUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.plugins.Page;
import com.xyc.cloud.bean.SysDict;
import com.xyc.cloud.dao.ISysDictDao;
import com.xyc.cloud.service.ISysDictService;
import com.xyc.cloud.utils.Dict;
import com.honghu.cloud.common.code.AppResponseCode;
import com.honghu.cloud.common.component.redis.utils.RedisUtil;
import com.honghu.cloud.common.utils.mybatis.Criteria;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@Transactional
public class SysDictServiceImpl implements ISysDictService {

	@Autowired
	private ISysDictDao sysDictDao;
	
	@Autowired
	private RedisUtil redisUtil;
	
	@Override
	public Page<SysDict> queryPage(Page<SysDict> page, Criteria<SysDict> param) {
		page.setRecords(sysDictDao.queryPage(page, param));
		return page;
	}

	@Override
	public Integer queryPageCount(Page<SysDict> page, Criteria<SysDict> param) {
		return (Integer) sysDictDao.queryPageCount(page, param);
	}

	@Override
	public SysDict queryEntityById(String id) {
		return sysDictDao.queryEntityById(id);
	}

	@Override
	public String insert(SysDict record) {
		int result = sysDictDao.insert(record);
		if (result != 1) {
			return AppResponseCode.RESPONSE_CODE_USER_INSERT_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String insertBatch(List<SysDict> list) {
		int result = sysDictDao.insertBatch(list);
		if (result != list.size()) {
			return AppResponseCode.RESPONSE_CODE_USER_INSERT_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String updateByCriteria(Criteria<SysDict> param) {
		int result = sysDictDao.updateByCriteria(param);
		if (result != 1) {
			return AppResponseCode.RESPONSE_CODE_USER_UPDATE_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String updateBatchByCriteria(List<SysDict> list) {
		int result = sysDictDao.updateBatchByCriteria(list);
		if (result == 0) {
			return AppResponseCode.RESPONSE_CODE_USER_UPDATE_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String insertOrUpdateBatch(List<SysDict> list) {
		int result = sysDictDao.insertOrUpdateBatch(list);
		if (result != list.size()) {
			return AppResponseCode.RESPONSE_CODE_USER_INSERT_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String deleteById(String id) {
		int result = sysDictDao.deleteById(id);
		if (result != 1) {
			return AppResponseCode.RESPONSE_CODE_USER_DEL_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String deleteByCriteria(Criteria<SysDict> param) {
		int result = sysDictDao.deleteByCriteria(param);
		if (result < 1) {
			return AppResponseCode.RESPONSE_CODE_USER_DEL_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public String deleteBatchByIds(String[] ids) {
		int result = sysDictDao.deleteBatchByIds(ids);
		if (result == 0) {
			return AppResponseCode.RESPONSE_CODE_USER_DEL_FALSE.getMessage();
		}
		return null;
	}

	@Override
	public <T> List<Map<String, Object>> translateToMapList(List<T> data) {

		List<Map<String, Object>> ret = new ArrayList<Map<String, Object>>();

		if (data == null || data.isEmpty()) {
			return ret;
		}

		Class<?> rowClazz = data.get(0).getClass();
		Field[] fields = FieldUtils.getAllFields(rowClazz);
		if (fields == null || fields.length < 1) {
			return ret;
		}

		for (Object rowData : data) {
			Map<String, Object> row = translateToMap(rowData);
			if (row != null) {
				ret.add(row);
			}
		}

		return ret;
	}
	
	@Override
	public Map<String, Object> translateToMap(Object obj) {

		Field[] fields = FieldUtils.getAllFields(obj.getClass());
		if (fields == null || fields.length < 1) {
			return null;
		}

		Map<String, Object> row = new HashMap<String, Object>();

		for (int i = 0; i < fields.length; i++) {

			Field aField = fields[i];
			Dict config = aField.getAnnotation(Dict.class);

			String fieldName = aField.getName();
			String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1, fieldName.length());
			try {
				Object value = MethodUtils.invokeMethod(obj, methodName);
				row.put(fieldName, value);

				if (config != null && !StringUtils.isEmpty(config.dictCode())) {

					if (value == null) {
						row.put(fieldName + "Zh", "");
						continue;
					}

					row.put(fieldName + "Zh", cachedValue(config.dictCode(), value.toString()));
				}

			} catch (Exception e) {
				if (log.isDebugEnabled()) {
					log.debug("dict translate fault.", e);
				}
			}
		}
		return row;
	}
	
	public static final String SERVICE_REDIS_COMMON = "REDIS_COMMON";
	
	
	public String cachedValue(String key, String value) {

		String cachedKey = String.format("dictCode=[%s]dictValue=[%s]", key, value);	
		String cachedValue = (String) redisUtil.get("common_"+cachedKey);
//		String cachedValue = redisUtil.getJedis(SERVICE_REDIS_COMMON, "common_"+cachedKey);

		if (null != cachedValue) {
			return cachedValue;
		}

		Criteria<SysDict> param = new Criteria<SysDict>();
		param.initParams().addParam("dictCode", key);
		param.addParam("dictValue", value);

		List<SysDict> tmp = sysDictDao.queryList(param);
		if (tmp != null && !tmp.isEmpty()) {
			cachedValue = tmp.get(0).getDictRemark() != null ? tmp.get(0).getDictRemark() : "";
		} else {
			cachedValue = "";
		}

		// 如果字典翻譯值爲空則不存入redis
		if (!StringUtils.isEmpty(cachedValue)) {
			redisUtil.set("common_"+cachedKey, cachedValue);
		}
		System.out.println("cachedKey -------------" + cachedKey +  "     cachedValue ----------------------" + cachedValue);
		return cachedValue;
	}

	@Override
	public List<Map<String, Object>> translateToMapList(List<Map<String, Object>> data, Map<String, String> transColumns) {

		if (data == null || data.isEmpty()) {
			return data;
		}

		if (transColumns == null || transColumns.isEmpty()) {
			return data;
		}

		for (Map<String, Object> row : data) {
			translateToMap(row, transColumns);
		}

		return data;
	}
	
	public Map<String, Object> translateToMap(Map<String, Object> obj, Map<String, String> transColumns) {

		if (obj == null || obj.isEmpty()) {
			return obj;
		}

		if (transColumns == null || transColumns.isEmpty()) {
			return obj;
		}

		for (Entry<String, String> column : transColumns.entrySet()) {
			if (obj.containsKey(column.getKey()) && null != obj.get(column.getKey())) {
				obj.put(column.getKey() + "Zh", cachedValue(column.getValue(), obj.get(column.getKey()).toString()));
			}
		}
		return obj;
	}
}