ID转名称到手方案01

> 好久没有写技术文章了，那就重新捡起来，从今天开始，分享这段时间的收获吧

------------
> ## 其实很多时候，我们只需要鱼，而不是渔，呐，给你鱼。

### 这次的分享主题是日常开发中，关于ID转Name的问题，常见的处理就两个方案：
1. 后端直接转换，前端只负责显示
2. 前端转换（常见的vue 过滤器等），后台不做任何处理

那么在什么时候应该选择什么方案呢，一般来讲会根据待转换数据的数量来决定，5k条以内两个方案都没有问题，但是数据量太大了之后
再选择前端转换的方案就会出现明显的卡顿，和加载缓慢的问题，所以会选择后台来处理，今天就给大家一个做好的鱼，拿好了，开始发了
哈~
如图，思路很简单，把工具当做一个容器，容器只提供两个方法：
1. 方法一用来接收数据源；
2. 方法二用来id转换成name

> 先看使用的例子吧：

### 带转换实体：

```
import java.util.Date;

@Data
public class DemoEntity {

//默认转换模式，转换到新的字段，默认字段名：原属性名+“_str”
@IdToName
private Integer aId;

//转换覆盖原属性
@IdToName(NewField = false)
private Integer bId;

//转换到新的字段，新字段名为 "cId_str"
@IdToName(Alias = "cId_str")
private Integer cId;

//格式化时间，默认格式为 "yyyy-MM-dd"
@IdToName(DateFormat = true)
private Date startTime;

//格式化时间，格式为 "yyyy-MM-dd HH:mm:ss"
@IdToName(DateFormat = true, FormatStr = "yyyy-MM-dd HH:mm:ss")
private Date endTime;

}
```
### 测试方法：

```
public static void main(String[] args) {
//1、准备数据源：
Map dataSource = new HashMap(1 list = new ArrayList();
list.add(demoEntity);

//4、转换实体
System.out.println(idToNameUtil.transportIdToName(list).toString());
}
```
### 测试结果：
[{aId_str=1a名称, startTime_str=2019-08-23, cId_str=3c名称, startTime=Fri Aug 23 11:24:30 CST 2019, endTime=Fri Aug 23 11:24:30 CST 2019, endTime_str=2019-08-23 11:24:30, AId=1, BId=2, bId=2b名称, CId=3}]

使用很简单，看完例子应该就可以上手了，尝试着写下吧；
**对了，转换10w数据的耗时在100ms+**

---

**下面就是具体的实现，更简单，一个自定义注解一个工具类，导入到项目就可以直接开始使用**：
1. 自定义注解：

```
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
public @interface IdToName {

/**
* 是否生成一个新的字段
*
* @return
*/
boolean NewField() default true;

/**
* 字段别名
*
* @return
*/
String Alias() default "";

/**
* 是否格式化时间
*
* @return
*/
boolean DateFormat() default false;

/**
* 时间格式(d:yyyy-MM-dd | s:yyyy-MM-dd HH:mm:ss)
*
* @return
*/
String FormatStr() default "yyyy-MM-dd";
}
```
2. 转换工具类：

```
import com.google.common.collect.Maps;
import com.hd.bizexpansion.annotation.IdToName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.*;

/**
* id转name工具类
*
* @author wang_yw
* @version 0.1
*/
@Component
public class IdToNameUtil {

private final Logger logger = LoggerFactory.getLogger(IdToNameUtil.class);

private Map sourceData = new HashMap();

/**
* 导入数据源
*
* @param sourceDataItem
*/
public void importSourceData(Map sourceDataItem) {
this.sourceData.putAll(sourceDataItem);
}

/**
* 转换方法
*
* @param items
* @return
*/
public List transportIdToName(List items) {
SimpleDateFormat sdf_d = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf_s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

if (this.sourceData.isEmpty() || items == null || items.isEmpty()) {
logger.warn("数据源为空，或者原数据为空");
}

//提前初始化结果集，长度等于参数数组避免长度自增浪费资源
List results = new ArrayList(items.size());

//遍历参数对象，开始id-name的翻译
for (Object object : items) {

Map item_map = this.beanToMap(object);
Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {

//如果包含注解进行处理
if (field.isAnnotationPresent(IdToName.class)) {
IdToName idToName = field.getAnnotation(IdToName.class);
field.setAccessible(true);
try {
if (field.get(object) == null) {
continue;
}

//类属性别名
String alias = idToName.Alias();
//新属性名
String newFieldName = StringUtils.isEmpty(alias) ? field.getName() + "_str" : alias;

//如果是时间需要格式化
if (idToName.DateFormat()) {
if ("yyyy-MM-dd".equals(idToName.FormatStr())) {
item_map.put(newFieldName, sdf_d.format((Date) field.get(object)));
} else if ("yyyy-MM-dd HH:mm:ss".equals(idToName.FormatStr())) {
item_map.put(newFieldName, sdf_s.format((Date) field.get(object)));
}
continue;
}

if (idToName.NewField()) {
item_map.put(newFieldName, sourceData.get(field.get(object)));
} else {
item_map.put(field.getName(), sourceData.get(field.get(object)));
}

} catch (IllegalAccessException e) {
e.printStackTrace();
}

}
}
results.add(item_map);
}

return results;
}

/**
* 对象转map
*
* @param bean
* @return
*/
private Map beanToMap(Object bean) {
Map map = Maps.newHashMap();
if (bean != null) {
BeanMap beanMap = BeanMap.create(bean);
for (Object key : beanMap.keySet()) {
map.put(String.valueOf(key), beanMap.get(key));
}
}
return map;
}

}
```

其实很多时候，我们只需要鱼，而不是渔，呐，给你鱼。
TO BE CONTINUE !