后台查询到前台所需,数据结构转换的通用方法(一) 结构转换

背景:

前台所需的数据结构和后台sql查询的数据结构一般不一致,该情况就涉及到了数据结构的转换,往往很多接口的查询都是固定两种数据结构的转化,这个时候就可以把这种转化关系抽离成一个通用的方法,避免大量的重复代码

前台数据结构:

{
year:[2010,2011,2012],
column1:[value,value,value],
column2:[value,value,value],
column3:[value,value,value]
}

后台数据结构:

id    year    column1    column2    column3
1     2010    value      value      value
2     2011    value      value      value
3     2012    value      value      value
4     2013    value      value      value

实现:

使用List<Map<String,Object>> 接收后台sql查询数据

select year,column1,column2,column3 from test where area_code = 110000 and year>=2010 and year <=2013

year 返回时不可重复

代码:

/**
	 * 转化数据结构返回给前端
	 * @param results
	 * @return
	 */
	private Map<String, Object> transfDataStruct(List<Map<String, Object>> results) {
		//key:{static_year:value}  管理引用的容器  static_year为年份
		Map<String,Map<Integer,Object>> manager = new HashMap<String,Map<Integer,Object>>();
		Set<String> keys;
		Integer staticYear;
		//static_year:value(具体的值)
		Map<Integer,Object> yearValue;
		Object value;
		List<Integer> yearList = new ArrayList<Integer>();
		for (Map<String, Object> map : results) {
			keys = map.keySet();
			staticYear = Integer.parseInt(map.get("static_year").toString());
			yearList.add(staticYear);
			for (String key : keys) {
				if("static_year".equals(key)) {
					continue;
				}
				yearValue = manager.get(key);
				if(yearValue==null) {
					yearValue = new HashMap<Integer,Object>();
					manager.put(key, yearValue);
				}
				value = map.get(key);
				yearValue.put(staticYear, value);
			}
		}
		if(!yearList.isEmpty()) {
			//年份排序
			Collections.sort(yearList);
			//定义结果集
			Map<String,Object> result = new HashMap<String,Object>();
			result.put("static_year", yearList);
			List<Object> resultList;
					
			
			//封装结果集
			Set<String> managerKeys = manager.keySet();
 			for (String key : managerKeys) {
 				resultList = new ArrayList<Object>();
 				result.put(key, resultList);
 				yearValue = manager.get(key);
				for (Integer year : yearList) {
					value = yearValue.get(year);
					resultList.add(value);
					
				}
			}
 			
			
 			return result;
		}
		return null;
	}

测试:

public static void main(String[] args) {
		MainTest test = new MainTest();
		List<Map<String,Object>> results = new ArrayList<Map<String,Object>>();
		Map<String,Object> result1 = new HashMap<String,Object>();
		results.add(result1);
		result1.put("static_year", 2010);
		result1.put("column1", 15);
		result1.put("column2", 16);
		result1.put("column3", 17);
		Map<String,Object> result2 = new HashMap<String,Object>();
		results.add(result2);
		result2.put("static_year", 2011);
		result2.put("column1", 151);
		result2.put("column2", 161);
		result2.put("column3", 171);
		Map<String,Object> result3 = new HashMap<String,Object>();
		results.add(result3);
		result3.put("static_year", 2012);
		result3.put("column1", 1511);
		result3.put("column2", 1611);
		result3.put("column3", 1711);
		Map<String, Object> transfDataStruct = test.transfDataStruct(results);
		System.out.println(transfDataStruct);
	}

结果:

{column1=[15, 151, 1511], static_year=[2010, 2011, 2012], column3=[17, 171, 1711], column2=[16, 161, 1611]}

后言:

上述代码中static_year作为排序字段是可以写活的,排序字段条件是查询结果中的唯一

排序正序反序也可以通过,参数传入,达到不同的排序规则