背景：
我们数据库为了减少存储容量和数据查询传输量以及增大查询效率，一般都会把字段进行编码而不是存中文，所以有时候字段值有可能是0 ==未处理，1 == 已处理。 但是，展示到前端需要将 值翻译成中文，如果人工来做会很麻烦，解放双手将此类工作交给程序来解决.
实现目标：
源码：自定义注解：DataDict，用于bo对象类，需要翻译的属性
package com.qboa.common.annotation.dict;
import java.lang.annotation.*;
/**
* 说明：数据字典处理类
* Created by luojie on 2019/05/29.
*/
//@DataDict( dict="patType", source = "patType" )
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDict {
/**
* 方法描述 描述标准编码 或是用户字段(对应UserBo)
* 与user配合使用,需要取的信息字段
* 如：要去age 则配置age 要取 userName 则配置 userName
*
* @return
*/
String dict() default "";
/**
* 翻译类型 "0" 标准代码 "1"用户
*
* @return
*/
String busi() default "0";
/**
* 方法描述,可使用占位符获取参数:{{source}}
* 主要标准编码之来源,
* 查询用户信息时存储用户userId 的字段名称
*/
String source() default "";
/**
* 对source 值是否需要对行转列进行拆分处理{{","}}
* 需要对source值按逗号进行拆分后翻译，默认拆分转换
* 若是{{$}}则按$进行拆分
* 默认不处理
* 如：
* "proMode": "1,2",
* "proModeName": "出售,结算",
*
* @return
*/
String transferLineColumn() default "";
/**
* 方法描述 描述标准编码组
* 翻译该字段需要哪些标准码
*
* @return
*/
String[] dictArr() default {};
/**
* 方法描述 区分字段，先决条件
* 决定取哪个标准编码
*
* @return
*/
String differ() default "";
/**
* 方法描述 区分字段，先决条件比较值
* 决定取哪个标准编码比较值
* 满足条件获取下标 从dictArr 中取下标的标准代码
*
* @return
*/
String[] differValues() default {};
}自定义注解：
DataDictClass 用来标注返回对象集合需要翻译的方法，本功能目前只支持bean对象的属性翻译package com.zddts.common.annotation.dict;
import java.lang.annotation.*;
/**
* 说明：
* Created by luojie on 2019/05/29.
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDictClass {
}切面处理： DataDictAspect
package com.qboa.oa.aop;
import com.alibaba.fastjson.JSON;
import com.qboa.common.annotation.dict.DataDict;
import com.qboa.common.annotation.dict.DataDictClass;
import com.qboa.common.bo.admin.UserBo;
import com.qboa.common.bo.pubapp.puCode.PuCodeBo;
import com.qboa.common.contants.ReidsConstants;
import com.qboa.common.utils.BeanUtils;
import com.qboa.oa.client.PubAppClient;
import com.qboa.oa.util.UserUtil;
import org.apache.commons.lang.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 说明：数据字典切面类
* Created by luojie on 2019/05/29.
*/
@Aspect
@Component
public class DataDictAspect {
@Autowired
PubAppClient pubappClient;
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
@Autowired
private UserUtil userUtil;
/**
* 非基本类型在 CLASS 中的定义
*/
private static final String FILED_NAME_TYPE = "TYPE";
private Map<String, String> dictInfoMap = new ConcurrentHashMap<>();
@Pointcut("@annotation(dataDictClass)")
public void doDataDictClass(DataDictClass dataDictClass) {
}
@Around("@annotation(dataDictClass)")
public Object translation(final ProceedingJoinPoint pjp, DataDictClass dataDictClass) throws Throwable {
Object result = pjp.proceed();
if (result == null) {
return result;
}
Object obj;
if (result instanceof List || result instanceof ArrayList) {
List olist = ((List) result);
if (olist.size() == 0) {
return result;
}
obj = olist.get(0);
} else if (result instanceof Page) {//支持Page类的数据字典转换
List olist = ((Page) result).getContent();
if (olist.size() == 0) {
return result;
}
obj = olist.get(0);
} else {
obj = result;
}
/**
* 获取翻译字段配置信息
*/
Map<String, DataDict> dataDictMap = boDict(obj.getClass());
if (dataDictMap.size() == 0) {
return result;
}
/**
* 获取字典信息
*/
this.getPCodeInfo();
/**
* 开始翻译
*/
if (result instanceof List || result instanceof ArrayList) {
for (Object o : (List) result) {
sign(o, dataDictMap, dictInfoMap);
}
} else if (result instanceof Page) {//支持Page类
((Page) result).forEach(o -> sign(o, dataDictMap, dictInfoMap));
} else {
sign(result, dataDictMap, dictInfoMap);
}
return result;
}
/**
* 设置数据字典
*/
public void getPCodeInfo() throws Exception {
Object codeObj = redisTemplate.opsForValue().get(ReidsConstants.PUCODE_REDIS_ALL);
List<PuCodeBo> dictInfos;
//缓存中没有重新从数据库中取
if (codeObj == null) {
dictInfos = pubappClient.getAllPuCode();
redisTemplate.opsForValue().set(ReidsConstants.PUCODE_REDIS_ALL, dictInfos);
} else {
dictInfos = (List<PuCodeBo>) codeObj;
}
if (dictInfos == null || dictInfos.size() == 0) {
return;
}
//先把字典值转成map
for (PuCodeBo puCodeBo : dictInfos) {
dictInfoMap.put(puCodeBo.getCodeType() + puCodeBo.getCodeValue(), puCodeBo.getCodeName());
}
}
/**
* 获取bo中属性值
*
* @param cla
* @return
*/
private Map<String, DataDict> boDict(Class cla) {
Field[] fields = cla.getDeclaredFields();
Map<String, DataDict> map = new HashMap<String, DataDict>();
for (Field field : fields) {
if (field.isAnnotationPresent(DataDict.class)) {
DataDict dataDict = field.getAnnotation(DataDict.class);
String fieldName = field.getName();
map.put(fieldName, dataDict);
}
}
return map;
}
/**
* 单个设置值
*
* @param obj
* @param dataDictMap 注解字段
* @param dictInfoMap
*/
public void sign(Object obj, Map<String, DataDict> dataDictMap, Map<String, String> dictInfoMap) {
for (Map.Entry<String, DataDict> entry : dataDictMap.entrySet()) {
String fileName = entry.getKey();
DataDict dataDict = entry.getValue();
String busi = StringUtils.isBlank(dataDict.busi()) ? "0" : dataDict.busi();
//翻译类型
if ("0".equals(busi)) {
this.setPCode(obj, dataDict, fileName, dictInfoMap);
} else if ("1".equals(busi)) {//翻译用户字段
this.setUserInfo(obj, dataDict, fileName);
}
}
}
/**
* 设置标准代码--字典
*
* @param obj
* @param dataDict 属性的注解字段配置
* @param fileName 需要赋值的字段
* @param dictInfoMap 字典信息数据
* @throws Exception
*/
public void setPCode(Object obj, DataDict dataDict, String fileName, Map<String, String> dictInfoMap) {
if (dictInfoMap == null || dictInfoMap.size() == 0) {
return;
}
String dict = dataDict.dict();
if (StringUtils.isBlank(dict)) {
String[] dictArr = dataDict.dictArr();//多个字典组 长度与differValues必须一致
String differ = dataDict.differ(); // 字典 选择条件字段 作区分的字段
String[] differValuesArr = dataDict.differValues();//differ 对应值的枚举值 匹配上选对应下标的dict字典来取值
try {
//作区分字段的值
String differValue = (String) BeanUtils.getBeanFieldValue(obj.getClass(), obj, differ);
if (StringUtils.isBlank(differValue)) {
//值无数据不比较
return;
}
for (int i = 0; i < differValuesArr.length; i++) {
if (differValue.equals(differValuesArr[i])) {
dict = dictArr[i];
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//未匹配上字典不设置
if (StringUtils.isBlank(dict)) {
return;
}
String source = dataDict.source();//需要翻译的字段
String transferLineColumn = dataDict.transferLineColumn();//拆分符号 有则按照拆分符号拆分翻译
try {
//获取源编码值
String sourceValue = (String) BeanUtils.getBeanFieldValue(obj.getClass(), obj, source);
String dictCodeName = null; //字典值 翻译后的值
//新增对例如1,2,3 多个值要标准码转换进行转换"proMode": "1,2", "proModeName": "出售,结算",
if (StringUtils.isNotBlank(transferLineColumn)) {
if (StringUtils.isNotBlank(sourceValue) && sourceValue.indexOf(transferLineColumn) > 0) {
String[] s = sourceValue.split(transferLineColumn);
for (int i = 0; i < s.length; i++) {
String a = s[i];
if (i == 0) {
dictCodeName = dictInfoMap.get(dict + a);
} else {
dictCodeName = dictCodeName + transferLineColumn + dictInfoMap.get(dict + a);
}
}
} else {
dictCodeName = dictInfoMap.get(dict + sourceValue);
}
} else {
dictCodeName = dictInfoMap.get(dict + sourceValue);
}
//设置值
BeanUtils.setBeanField(obj.getClass(), obj, fileName, dictCodeName);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 设置用户信息
*
* @param obj
* @param dataDict 属性注解字段配置
* @param fileName 需要赋值的字段
* @throws Exception
*/
public void setUserInfo(Object obj, DataDict dataDict, String fileName) {
String source = dataDict.source(); //存储用户userId 的字段名称
String dict = dataDict.dict();//获取用户目标信息的字段
if (StringUtils.isBlank(dict)) {
return;
}
try {
Object userIdobj = BeanUtils.getBeanFieldValue(obj.getClass(), obj, source);
if (userIdobj == null) {
return;
}
String userIdstr = String.valueOf(userIdobj);
if ("".equals(userIdstr)) {
return;
}
Long userId = Long.valueOf(userIdstr);
//查询用户信息 根据自己配置是数据库还是redis
UserBo user = userUtil.getUserBoInRedis(userId);
if (user == null) {
return;
}
//todo 目前支持字符串类型 数值类型，不支持对象 类型 和时间类型 目标和源 的类型必须要一致
Object fromValue = BeanUtils.getBeanFieldValue(user.getClass(), user, dict);
//设置值
BeanUtils.setBeanField(obj.getClass(), obj, fileName, fromValue);
} catch (Exception e) {
e.printStackTrace();
return;
}
}
/**
* json处理 todo
*
* @param returnJsonResult
* @param returnType
* @return
*/
private Object getJsonToResultObject(String returnJsonResult, Class returnType) {
// 对象复原
if (StringUtils.isNotBlank(returnJsonResult)) {
// 基本类型则直接返回封装类型则对象转换
if (returnType.isPrimitive()) {
return returnJsonResult;
} else {
try {
if ((returnType.getField(FILED_NAME_TYPE)
.getClass()).isPrimitive()) {
return returnJsonResult;
}
} catch (Exception e) {
return JSON.parseObject(returnJsonResult, returnType);
}
}
}
return null;
}
}工具类：主要用了反射机制
package com.zddts.common.utils;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;
public class BeanUtils {
/**
* 方法说明：将List<Map>转换为List<Bean>
*
* @param mapList
* @param cls
* @return
* @throws Exception
*/
public static List<Object> mapListToBeanList(
List<Map<String, Object>> mapList, Class<?> cls) throws Exception {
if (mapList == null || mapList.size() == 0) {
return null;
}
List<Object> beanList = new ArrayList<Object>();
Object bean = null;
for (Map<String, Object> map : mapList) {
bean = mapToBean(map, cls);
if (bean == null) {
continue;
}
beanList.add(bean);
}
return beanList;
}
/**
* 设置bean 属性值,没有下划线的
*
* @param map
* @param cls
* @return
* @throws Exception
*/
public static Object mapToBeanNL(Map<String, Object> map, Class<?> cls) throws Exception {
if (map == null || map.size() == 0) {
return null;
}
Object obj = cls.newInstance();
for (Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (value == null) {
continue;
}
// 判断字段是否存在
String fieldName = key;
Field field = getBeanField(cls, fieldName);
if (field == null) {
continue;
}
// 判断字段的set方法是否存在
String setMethodName = StringUtils.pareSetName(fieldName);
Method method = getBeanMethod(cls, setMethodName, field.getType());
if (method == null) {
continue;
}
String fieldType = field.getType().getSimpleName();
if ("String".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
method.invoke(obj, Long.valueOf(value.toString()));
} else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
method.invoke(obj, Double.valueOf(value.toString()));
} else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
method.invoke(obj, Float.valueOf(value.toString()));
} else if ("boolean".equals(fieldType) || "Boolean".equals(fieldType)) {
if (value.getClass().equals(Boolean.class)) {
method.invoke(obj, (Boolean) value);
} else {
method.invoke(obj, Boolean.valueOf(value.toString()));
}
} else if ("Date".equals(fieldType)) {
if (value != null) {
if (value.getClass().equals(Date.class)) {
method.invoke(obj, (Date) value);
} else {
method.invoke(obj, DateUtils.strToDate(value.toString()));
}
}
}
}
return obj;
}
/**
* 设置bean 属性值
*
* @param map
* @param cls
* @return
* @throws Exception
*/
public static Object mapToBean(Map<String, Object> map, Class<?> cls)
throws Exception {
if (map == null || map.size() == 0) {
return null;
}
Object obj = cls.newInstance();
for (Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (value == null) {
continue;
}
// 判断字段是否存在
String fieldName = StringUtils.toUnderLine(key.toLowerCase());
Field field = getBeanField(cls, fieldName);
if (field == null) {
continue;
}
// 判断字段的set方法是否存在
String setMethodName = StringUtils.pareSetName(fieldName);
Method method = getBeanMethod(cls, setMethodName, field.getType());
if (method == null) {
continue;
}
String fieldType = field.getType().getSimpleName();
if ("String".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
method.invoke(obj, Long.valueOf(value.toString()));
} else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
method.invoke(obj, Double.valueOf(value.toString()));
} else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
method.invoke(obj, Float.valueOf(value.toString()));
} else if ("boolean".equals(fieldType)
|| "Boolean".equals(fieldType)) {
if (value.getClass().equals(Boolean.class)) {
method.invoke(obj, (Boolean) value);
} else {
method.invoke(obj, Boolean.valueOf(value.toString()));
}
} else if ("Date".equals(fieldType)) {
if (value != null) {
if (value.getClass().equals(Date.class)) {
method.invoke(obj, (Date) value);
} else {
method.invoke(obj, DateUtils
.strToDate(value.toString()));
}
}
}
}
return obj;
}
/**
* 方法说明：将List<Bean>转换为List<Map>
*
* @param beanList
* @return
* @throws Exception
*/
public static List<Map<String, Object>> beanListToMapList(
List<Map<String, Object>> beanList) throws Exception {
if (beanList == null || beanList.size() == 0) {
return null;
}
List<Map<String, Object>> mapList = new ArrayList<Map<String, Object>>();
Map<String, Object> map = null;
for (Object bean : beanList) {
map = beanToMap(bean);
if (map == null || map.size() == 0) {
continue;
}
mapList.add(map);
}
return mapList;
}
/**
* 设置bean 属性值
*
* @param bean
* @return
* @throws Exception
*/
public static Map<String, Object> beanToMap(Object bean) throws Exception {
if (bean == null) {
return null;
}
Map<String, Object> map = new HashMap<String, Object>();
Class<?> cls = bean.getClass();
Field fields[] = cls.getDeclaredFields();
for (Field field : fields) {
String fieldName = field.getName();
String fieldType = field.getType().getSimpleName();
boolean isBooleanType = false;
if (fieldType.equals("boolean") || fieldType.equals("Boolean")) {
isBooleanType = true;
}
String getMethodName = StringUtils.pareGetName(fieldName,
isBooleanType);
// 判断字段的无参get方法是否存在
Method method = getBeanMethod(cls, getMethodName, new Class[]{});
if (method == null) {
continue;
}
Object fieldValue = method.invoke(bean, new Object[]{});
map.put(StringUtils.toUnderLine(field.getName()).toUpperCase(),
fieldValue);
}
return map;
}
/**
* 判断该方法是否存在
*
* @param methods
* @param met
* @return
*/
public static boolean checkMethod(Method methods[], String met) {
if (null != methods) {
for (Method method : methods) {
if (met.equals(method.getName())) {
return true;
}
}
}
return false;
}
/**
* 方法说明：获取bean的指定方法
* <p>
* <p>
* Author： zhenqiangs Create Date： 2016-4-30 下午01:07:12 History: 2016-4-30
* 下午01:07:12 zhenqiangs Created.
*
* @param cls
* @param methodName
* @param paramTypes
* @return
*/
private static Method getBeanMethod(Class<?> cls, String methodName,
Class<?>... paramTypes) {
if (cls == null) {
return null;
}
Method setMethod = null;
try {
setMethod = cls.getMethod(methodName, paramTypes);
} catch (Exception e) {
}
return setMethod;
}
/**
* 方法说明：获取bean的指定属性
*
* @param cls
* @param fieldName
* @return
*/
public static Field getBeanField(Class<?> cls, String fieldName) {
if (cls == null) {
return null;
}
Field field = null;
try {
field = cls.getDeclaredField(fieldName);
} catch (Exception e) {
}
return field;
}
/**
* 设置对应值
*
* @param fieldName
*/
public static void setBeanField(Class<?> cls, Object obj, String fieldName, Object value) throws Exception {
// 判断字段是否存在
Field field = getBeanField(cls, fieldName);
if (field == null) {
return;
}
// 判断字段的set方法是否存在
String setMethodName = StringUtils.pareSetName(fieldName);
Method method = getBeanMethod(cls, setMethodName, field.getType());
if (method == null) {
return;
}
//为空不设置
if (value == null) {
return;
}
String fieldType = field.getType().getSimpleName();
if ("String".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
method.invoke(obj, Long.valueOf(value.toString()));
} else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
method.invoke(obj, value.toString());
} else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
method.invoke(obj, Double.valueOf(value.toString()));
} else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
method.invoke(obj, Float.valueOf(value.toString()));
} else if ("boolean".equals(fieldType) || "Boolean".equals(fieldType)) {
if (value.getClass().equals(Boolean.class)) {
method.invoke(obj, (Boolean) value);
} else {
method.invoke(obj, Boolean.valueOf(value.toString()));
}
} else if ("Date".equals(fieldType)) {
if (value.getClass().equals(Date.class)) {
method.invoke(obj, (Date) value);
} else {
method.invoke(obj, DateUtils.strToDate(value.toString()));
}
}
}
/**
* 设置对应值
*
* @param fieldName
*/
public static Object getBeanFieldValue(Class<?> cls, Object obj, String fieldName) throws Exception {
// 判断字段是否存在
Field field = getBeanField(cls, fieldName);
// 判断字段的set方法是否存在
String getMethodName = StringUtils.pareGetName(fieldName, false);
// 判断字段的无参get方法是否存在
Method method = getBeanMethod(cls, getMethodName, new Class[]{});
Object fieldValue = method.invoke(obj, new Object[]{});
return fieldValue;
}
}StringUtils
/**
*
*/
package com.zddts.common.utils;
import java.net.URLEncoder;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author Luojie
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils {
/**
* 合并字符串数组为一个串
*
* @param src String[] 字符串数组
* @param delimiter 隔开字符
* @return String
*/
public static String merge(String[] src, String delimiter) {
StringBuffer newSrc = new StringBuffer();
for (int i = 0; i < src.length; i++) {
if (i < src.length - 1) {
newSrc.append(src[i]).append(delimiter);
} else {
newSrc.append(src[i]);
}
}
return newSrc.toString();
}
/**
* 分解字符串
*
* @param str String
* @param sect int 分解的段数
* @param len int 每段的字符长度
* @return String[]
* @throws Exception
*/
static public String[] split(String str, int sect, int len)
throws Exception {
String[] result = new String[sect];
int j = 0;
for (j = 0; j < sect; j++) {
result[j] = "";
}
for (j = 0; j < sect; j++) {
if (str.length() < len * j) {
break;
} else if (str.length() < len * (j + 1)) {
result[j] = str.substring(len * j, str.length());
} else {
result[j] = str.substring(len * j, len * (j + 1));
}
}
return result;
}
/**
* 对整个url进行编码转换
*
* @param srcStr url串
* @param encoding 编码
* @return String
*/
public static String URLEncode(String srcStr, String encoding) {
String[] arrayUrl = srcStr.split("?");
if (arrayUrl.length <= 1) {
return srcStr;
}
String qryStr = arrayUrl[1];
String[] arrayQryStr = qryStr.split("&");
StringBuffer newQryStr = new StringBuffer(120);
StringBuffer tmp = new StringBuffer(20);
String param;
for (int i = 0; i < arrayQryStr.length; i++) {
param = arrayQryStr[i];
String[] arrayParam = param.split("=");
if (arrayParam.length > 1) {
try {
arrayParam[1] = URLEncoder.encode(arrayParam[1], encoding);
} catch (Exception e) {
e.printStackTrace();
}
tmp.append(arrayParam[0]).append("=").append(arrayParam[1]);
arrayQryStr[i] = tmp.toString();
} else {
tmp.append(arrayParam[0]).append("=");
arrayQryStr[i] = tmp.toString();
}
newQryStr.append(arrayQryStr[i]).append("&");
}
tmp = new StringBuffer(150);
tmp.append(arrayUrl[0]).append("?").append(newQryStr.toString());
return tmp.toString();
}
/**
* 用 newString 替换 line 中的所有的 OldString。 不支持正则表达式
*
* @param line 原字符串
* @param oldString 被替换的字符串
* @param newString 新的要替换oldString的字符串
* @return 返回所有oldString都被newString替换的字符串
*/
public static final String replace(String line, String oldString,
String newString) {
// 如果line是null，直接返回
if (line == null) {
return null;
}
int i = 0;
// 如果在line中确实存在oldString那么将进行以下的替换
if ((i = line.indexOf(oldString, i)) >= 0) {
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuffer buf = new StringBuffer(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = line.indexOf(oldString, i)) > 0) {
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
return buf.toString();
}
// 如果在line中没有oldString 返回line
return line;
}
/**
* 用 newString 替换 line 中的所有的 OldString count返回被替换的数目
*
* @param line 原字符串
* @param oldString 被替换的字符串
* @param newString 新的要替换oldString的字符串
* @return 返回所有oldString都被newString替换的字符串
*/
public static final String replace(String line, String oldString,
String newString, int[] count) {
if (line == null) {
return null;
}
int i = 0;
if ((i = line.indexOf(oldString, i)) >= 0) {
int counter = 0;
counter++;
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuffer buf = new StringBuffer(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = line.indexOf(oldString, i)) > 0) {
counter++;
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
count[0] = counter;
return buf.toString();
}
return line;
}
/**
* 做不区分大小写的模式匹配，并用newString 来替换 oldString
*
* @param line 原字符串
* @param oldString 被替换的字符串
* @param newString 新的要替换oldString的字符串
* @return 返回所有oldString都被newString替换的字符串
*/
public static final String replaceIgnoreCase(String line, String oldString,
String newString) {
// 如果line是null，直接返回
if (line == null) {
return null;
}
String lcLine = line.toLowerCase();
String lcOldString = oldString.toLowerCase();
int i = 0;
if ((i = lcLine.indexOf(lcOldString, i)) >= 0) {
char[] line2 = line.toCharArray();
char[] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuffer buf = new StringBuffer(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = lcLine.indexOf(lcOldString, i)) > 0) {
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
return buf.toString();
}
return line;
}
/**
* 从数组中得到字符串的位置
*
* @param s 要查询的字符串
* @param args 待查的数组
* @return s的位置，没有找到就是-1
*/
public static int getStrIndex(String s, String args[]) {
int length = args.length;
for (int i = 0; i < length; i++) {
if (args[i].equals(s)) {
return i;
}
}
return -1;
}
/**
* 判断 如果输入的字符为null或者'null',输出空字符串""
*
* @param src
* @return
*/
public static String nullToEmpty(String src) {
if (src == null || src.equalsIgnoreCase("NULL")) {
return "";
}
return src;
}
/**
* 将下划线连接的String替换为驼峰风格
*
* @param s
* @return
*/
public static String toCamelCasing(String s) {
if (s == null) {
return s;
}
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < s.length() - 1; i++) {
char ch = s.charAt(i);
if (ch != '_') {
buffer.append(ch);
} else {
char nextChar = s.charAt(i + 1);
if (nextChar != '_') {
// if (buffer.toString().length() < 2) {
// buffer.append(Character.toLowerCase(nextChar));
// } else {
buffer.append(Character.toUpperCase(nextChar));
// }
i++;
}
}
}
char lastChar = s.charAt(s.length() - 1);
if (lastChar != '_') {
buffer.append(lastChar);
}
return buffer.toString();
}
/**
* 将驼峰结构的字符串转换为下划线连接的形式
*
* @param s
* @return
*/
public static String toUnderLine(String s) {
if (s == null) {
return s;
}
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < s.length() - 1; i++) {
char ch = Character.toLowerCase(s.charAt(i));
char nextChar = s.charAt(i + 1);
if (Character.isUpperCase(nextChar)) {
buffer.append(ch).append('_');
} else {
buffer.append(ch);
}
}
char lastChar = s.charAt(s.length() - 1);
buffer.append(Character.toLowerCase(lastChar));
return buffer.toString();
}
/**
* 将首字母小写
*
* @param s
* @return
*/
public static String lowerFirstChar(String s) {
if (s == null || s.trim().equals("")) {
return null;
}
StringBuffer buffer = new StringBuffer();
buffer.append(Character.toLowerCase(s.charAt(0)))
.append(s.substring(1));
return buffer.toString();
}
/**
* 将首字母大写
*
* @param s
* @return
*/
public static String upperFirstChar(String s) {
if (s == null || s.trim().equals("")) {
return null;
}
StringBuffer buffer = new StringBuffer();
buffer.append(Character.toUpperCase(s.charAt(0)))
.append(s.substring(1));
return buffer.toString();
}
/**
* 拼接某属性get 方法
*
* @param isBooleanType 属性是否为boolean型
* @return
*/
public static String pareGetName(String fieldName, Boolean isBooleanType) {
String str = StringUtils.upperFirstChar(fieldName);
if (str == null) {
return null;
}
if (isBooleanType) {
return "is" + str;
} else {
return "get" + str;
}
}
/**
* 拼接某属性set 方法
*
* @return
*/
public static String pareSetName(String fieldName) {
String str = StringUtils.upperFirstChar(fieldName);
if (str == null) {
return null;
}
String pro = "set" + str;
return pro;
}
/**
* 方法说明：判断字符串是否为空
*
* @param paramString
* @return
*/
public static boolean nullOrBlank(String paramString) {
return (paramString == null) || (paramString.trim().equals(""));
}
/**
* 方法说明：判断字符串是否为空
* List
*
* @return
*/
public static boolean notNullOrBlankList(List list) {
if (list == null || list.size() == 0) {
return false;
}
return true;
}
/**
* 方法说明：字符串为空时给默认值
*
* @param str
* @param defaultValue
* @return
*/
public static String strNvl(String str, String defaultValue) {
if (nullOrBlank(str)) {
return defaultValue;
}
return str;
}
/**
* 方法说明：字符串为空时给默认值
*
* @param strObj
* @param defaultValue
* @return
*/
public static String strObjNvl(Object strObj, String defaultValue) {
String str = null;
if (strObj != null) {
str = strObj.toString();
}
return strNvl(str, defaultValue);
}
/**
* 方法说明：获取第N个a字符后面的所有字符
* <p>
* <p>
* Author： 高宝阳 Create Date： May 5, 2016 6:04:10 PM History: May 5, 2016
* 6:04:10 PM Administrator Created.
*
* @param sChar
* @param n
* @return
*/
public static String getNCharAfter(String sInput, String sChar, int n) {
// 这里是获取sChar符号的位置
String str = null;
int m = 1;
int i = 0;
while (sInput.indexOf(sChar, i) >= 0) {
i = sInput.indexOf(sChar, i) + 1;
if (n == m) {
str = sInput.substring(i, sInput.length());
break;
}
m = m + 1;
}
return str;
}
/**
* 根据传入的字符串判断将来的数组长度，用于系统参数的解析
*
* @param sInput 字符串
* @return
* @throws Exception
*/
public static int getArrLen(String sInput) throws Exception {
int len = 0;
int i = 0;
while (sInput.indexOf("$", i) > 0) {
i = sInput.indexOf("$", i) + 1;
len = len + 1;
}
return len;
}
/**
* 字符串解释成数组
*
* @param sInput 字符串格式：例如：w$m$n$o$p$ w: 位数；m、n、o、p分别为字符串；如实际的例子：4$122$+$01$1$
* @return
* @throws Exception
*/
public static String[] stringParse(String sInput) throws Exception {
String[] sRet = null;
try {
int len = getArrLen(sInput);
int m = -1;
sRet = new String[len];
for (int j = 0; j < len; j++) { // 数组
sRet[j] = sInput.substring(m + 1, sInput.indexOf("$", m + 1));
m = sInput.indexOf("$", m + 1);
}
} catch (Exception e) {
System.out.println(e.getMessage());
throw new Exception(e.getMessage());
}
return sRet;
}
/**
* replaceBlank
*
* @param in
* @return
* @description replaceBlank
*/
public static String replaceBlank(String in) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
Matcher m = p.matcher(in);
String after = m.replaceAll("");
return after;
}
/**
* 删除起始字符
*
* @param str
* @return
* @author xxj 2017年4月27日
*/
public static String trimStart(String str, String trim) {
if (str == null) {
return null;
}
return str.replaceAll("^(" + trim + ")+", "");
}
/**
* 删除末尾字符
*
* @param str
* @return
* @author xxj 2017年4月27日
*/
public static String trimEnd(String str, String trim) {
if (str == null)
return null;
return str.replaceAll("(" + trim + ")+$", "");
}
public static Object nullToDefault(Object obj, Object def) {
if (obj == null) {
return def;
}
return obj;
}
private static final String UNIT = "万千佰拾亿千佰拾万千佰拾元角分";
private static final String DIGIT = "零壹贰叁肆伍陆柒捌玖";
private static final double MAX_VALUE = 9999999999999.99D;
public static String changeMoney(double v) {
if (v < 0 || v > MAX_VALUE) {
return "参数非法!";
}
long l = Math.round(v * 100);
if (l == 0) {
return "零元整";
}
String strValue = l + "";
// i用来控制数
int i = 0;
// j用来控制单位
int j = UNIT.length() - strValue.length();
String rs = "";
boolean isZero = false;
for (; i < strValue.length(); i++, j++) {
char ch = strValue.charAt(i);
if (ch == '0') {
isZero = true;
if (UNIT.charAt(j) == '亿' || UNIT.charAt(j) == '万' || UNIT.charAt(j) == '元') {
rs = rs + UNIT.charAt(j);
isZero = false;
}
} else {
if (isZero) {
rs = rs + "零";
isZero = false;
}
rs = rs + DIGIT.charAt(ch - '0') + UNIT.charAt(j);
}
}
if (!rs.endsWith("分")) {
rs = rs + "整";
}
rs = rs.replaceAll("亿万", "亿");
return rs;
}
public static boolean isBlank(String str) {
if (str == null || "".equals(str.trim())) {
return true;
} else {
return false;
}
}
public static boolean isNotBlank(String str) {
if (str != null && !"".equals(str.trim())) {
return true;
} else {
return false;
}
}
public static String isGoodPat(String patNo) {
patNo = patNo.replaceFirst("[a-zA-Z]*", "").replace(".", "").replace(" ", "");
if (!patNo.substring(0, patNo.length() - 1).matches("[0-9]*$") || (patNo.length() != 13 && patNo.length() != 7)) {
return null;
}
return patNo;
}
/**
* 更具专利号判断专利类型
* 一定要是中国13位专利
* @param patNo
* @return
*/
public static String getPatType(String patNo) {
if (StringUtils.isEmpty(patNo) || patNo.length() <= 5)
return null;
String patType = patNo.substring(4, 5);
if ("8".equals(patType))
patType = "1";
if ("9".equals(patType))
patType = "2";
return patType;
}
public static void main(String args[]) {
System.out.print(isGoodPat("20171141704x"));
}
}使用：
需要注解翻译的BO对象属性上加上注解DataDict ，dict是指标准码的编码或者用户UserBo的属性 （字典名称），
source 值字段翻译值的来源
//汇聚类的字典解析相应配置上 transFerLineColumn 如逗号拆分的配置“,”
字典配置：1 = 出售 2 =结算
数据库聚合存储的为1,2 需要翻译的
效果如图：
//用户字段使用方法
dao层 使用：
或者service 层 使用：
对要数据字典转换的方法加上DataDictClass注解
执行效果
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
