springboot 前端上传json文件到指定目录，后端读取并处理，处理完在封装成json文件写入到指定文件中

先读取对应的json文件

	@Value("${jeecg.path.uploadFile}")
	private String uploadFileURL;
	@Value("${jeecg.path.accessPublicPath}")
	private String accessPublicPath;

	//读取并解析文件
    private void readFile(StringBuilder sb, String id, Integer batch) throws IOException {
		String path = uploadFileURL+"//unzipFile//"+id+"//"+batch +"//equipments.json";
		File jsonFile = new File(path);
		FileReader fileReader = new FileReader(jsonFile);
		Reader reader = new InputStreamReader(new FileInputStream(jsonFile),"utf-8");
		int ch = 0;
		while ((ch = reader.read()) != -1) {
			sb.append((char) ch);
		}
		fileReader.close();
		reader.close();
	}

然后对JSON文件进行处理

public JsonResponse parsingJsON(String id, Integer batch) {
		try {
			StringBuilder sb = new StringBuilder();
			readFile(sb, id, batch);
			Map<String, Object> map = JsonUtils.jSONObjectToMap((JSONObject) JSONArray.parse(sb.toString()));
			List<Map<String, Object>> list = (List) map.get("cabinetData"); 
			for (Map<String, Object> m : list) { //这部分是对里面数据进行处理也可以不封装成JavaBean对象直接转成JSONArray进行遍历取值也行，下面会有例子
				ThreeDimensionAssets cabinetData = JsonUtils.mapToObject(m, ThreeDimensionAssets.class);
				ThreeDimensionAssets tda = threeDimensionAssetsService.getInfoByUuid(cabinetData.getUuid(),id);
				if (!org.springframework.util.StringUtils.isEmpty(tda)) {
					cabinetData.setAssetsId(tda.getAssetsId());
				}
                cabinetData.setRoomId(id);
                cabinetData.setBatch(batch);
                cabinetData.setParentUuid("0");
                threeDimensionAssetsService.saveInfo(cabinetData);
                recursiveSave(id, cabinetData, batch);
            }
			//更新列表是否已解析字段
			roomService.updateIsParseById(id);
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
			return errorJson("找不到对应的文件，解析失败！");
		} catch (IOException ex) {
			ex.printStackTrace();
			return errorJson("文件读取错误，解析失败！");
		}
		return okJson();
	}

	//递归封装Json信息
	private void recursiveSave(String id, ThreeDimensionAssets cabinetData, Integer batch) {
		if (cabinetData.getChildrens() != null && cabinetData.getChildrens().size() > 0){
			List<ThreeDimensionAssets> threeDimensionAssetsList = cabinetData.getChildrens();
			for (ThreeDimensionAssets threeDimensionAssets : threeDimensionAssetsList) {
				threeDimensionAssets.setRoomId(id);
				threeDimensionAssets.setBatch(batch);
				threeDimensionAssets.setParentUuid(cabinetData.getUuid());
				threeDimensionAssetsService.saveInfo(threeDimensionAssets);
				recursiveSave(id, threeDimensionAssets, batch);
			}
		}
	}

用到的工具类JsonUtils

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;

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

public class JsonUtils {
    /**
     * **方法功能说明：JSONObject 转化  Map**
     */
    public static Map<String, Object> jSONObjectToMap(JSONObject o){
        return JSONObject.parseObject(o.toJSONString(), new TypeReference<Map<String, Object>>(){});
    }
    public static JSONObject mapToJSONObject(Map<String, Object> itemMap){
        return JSONObject.parseObject(JSON.toJSONString(itemMap));
    }

    /**
     * **方法功能说明：javaBean 转json多想**
     */
    public static <T> JSONObject javaBean2Json(T t) {
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(t);
        return jsonObject;
    }


    /**
     * **方法功能说明：json 字符串转javaBean对象**
     */
    public static <T> T json2JavaBean(String json,Class<T> clazz) {
        return JSONObject.parseObject(json,clazz);
    }

    /**
     * **方法功能说明：将String对象专程jsonObject**
     */
    public static JSONObject stringToJsonObject(String json) {
        return  JSONObject.parseObject(json);
    }


    /**
     * **方法功能说明：map转javaBean对象**
     */
    public static <T> T mapToObject(Map<String, Object> params,Class<T> clazz) {
        return JSON.parseObject(JSON.toJSONString(params), clazz);
    }

    /**
     * **方法功能说明：将String对象专程jsonObject**
     */
    public static JSONArray stringToJsonArray(String json) {
        return JSONArray.parseArray(json);
    }

    /**
     * **List<T> 转 json 保存到数据库**
     */
    public static <T> String listToJson(List<T> ts) {
        return JSON.toJSONString(ts);
    }

    /**
     * **json 转 List<T>**
     */
    public static <T> List<T> jsonToList(String jsonString, Class<T> clazz) {
        return (List<T>) JSONArray.parseArray(jsonString, clazz);
    }

处理完json数据再封装成原来结构写入之前文件中

public JsonResponse backJsON(@RequestParam(value="id",required=true) String id) {
		try {
			ThreeDimensionRoom room = roomService.selectByPrimaryKey(id);
			Integer batch = room.getBatch();
			StringBuilder sb = new StringBuilder();
			readFile(sb, id, batch); //和上面方法一样
			JSONObject obj = JSON.parseObject(sb.toString()); //这种处理办法就是上文说的另外一种处理方式
			JSONArray movies = obj.getJSONArray("cabinetData");
			for (int i = 0 ; i < movies.size();i++){
				JSONObject key = (JSONObject)movies.get(i);
				String uuid = (String)key.get("uuid");
				ThreeDimensionAssets tda = threeDimensionAssetsService.selectAssetsByUUid(uuid, id, batch);
				if (!org.springframework.util.StringUtils.isEmpty(tda)) {
					ResourceAssetsWithBLOBs infoById = assetsService.getAssetsById(tda.getAssetsId());
					if (!org.springframework.util.StringUtils.isEmpty(infoById)) {
						key.put("data",infoById);
					}
				}
				recursiveBack(id, key, batch);
			}
			obj.put("cabinetData",movies);
			writerFile(obj,id,batch);

			FileUtil.deleteFile(new File(accessPublicPath)); //清空访问路径
			FileUtil.copyFolder(uploadFileURL+"//unzipFile//"+id+"//"+batch, accessPublicPath); //复制文件
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
			return errorJson("找不到对应的文件，解析失败！");
		} catch (IOException ex) {
			ex.printStackTrace();
			return errorJson("文件读取错误，解析失败！");
		}
		return okJson();
	}
	
	//递归封装Json信息
    private void recursiveBack(String id, JSONObject obj, Integer batch) {
		JSONArray movies = obj.getJSONArray("childrens");
		if (movies!=null) {
			for (int i = 0 ; i < movies.size();i++){
				JSONObject key = (JSONObject)movies.get(i);
				String uuid = (String)key.get("uuid");
				ThreeDimensionAssets tda = threeDimensionAssetsService.selectAssetsByUUid(uuid, id, batch);
				if (!org.springframework.util.StringUtils.isEmpty(tda)) {
					ResourceAssetsWithBLOBs infoById = assetsService.getAssetsById(tda.getAssetsId());
					if (!org.springframework.util.StringUtils.isEmpty(infoById)) {
						key.put("data",infoById);
					}
				}
				recursiveBack(id, key, batch);
			}
		}
    }

	//把文件写入磁盘文件中
	private void writerFile(JSONObject obj,String id, Integer batch) throws IOException {
		FileWriter fw = null;
		try {
			//创建字符输出流对象，负责向文件内写入
			fw = new FileWriter(uploadFileURL+"//unzipFile//"+id+"//"+batch +"//equipments.json");
			//将str里面的内容读取到fw所指定的文件中
			fw.write(obj.toJSONString());
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fw!=null){
				fw.close();
			}
		}
	}