WMS倉儲系統對接奇門雲網關Java接口實現

介紹：

基於spring框架 實現的奇門雲網關 WMS端 通用API方法

編碼思路：

1.接收ERP端xml類型的參數（request.getInputStream()），為方便取值轉換為Json格式（xmlForJson(sb.toString())）

2.判斷ERP端請求的奇門接口名稱（request.getParameter("method")）走不同的業務實現方法（switch case注釋部分），各接口返回數據均有差異，請參照淘寶奇門接口API文檔

3.各實現方法返回Map格式數據，轉換為xml格式返回，為防止亂碼情況，我們轉為byte數組返回（multilayerMapToXml(resultMap, false).getBytes("UTF-8")）

代碼實現：

package org.tempuri;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.mingsoft.util.StringUtil;
import net.sf.json.JSONObject;
import net.sf.json.xml.XMLSerializer;

@Controller
@RequestMapping("api/open/qiMenApi")
public class QiMenTest {

    @ResponseBody
    @RequestMapping(value="/apiRealization",produces="text/xml;charset=UTF-8")
    public byte[] apiRealization(HttpServletRequest request, HttpServletResponse response) {
        // AppKey
        String appKeyVal = request.getParameter("app_key");
        // API接口名稱
        String methodVal = request.getParameter("method");
        // 時間戳，格式：yyyy-MM-dd HH:mm:ss
        String timestampVal = request.getParameter("timestamp");
        // 請求簽名
        String signVal = request.getParameter("sign");
        byte[] result = null;
        Map<String, Object> resultMap = new HashMap<>();
        InputStream inputStream;
        StringBuffer sb = new StringBuffer();
        try {
            // 解析xml參數
            inputStream = request.getInputStream();
            String s;
            BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            while ((s = in.readLine()) != null) {
                sb.append(s);
            }
            in.close();
            inputStream.close();
            if(sb.length() > 0) {
                // json格式的報文參數
                JSONObject xmlToJson = JSONObject.fromObject(xmlForJson(sb.toString()));
                if(!StringUtil.isBlank(methodVal)) {
                    switch (methodVal) {
                        case "deliveryorder.create":
                            // 發貨單創建接口
                            //resultMap = ;
                            break;
                        case "entryorder.create":
                            // 入庫單創建接口
                            //resultMap = ;
                            break;
                        case "stockout.create":
                            // 出庫單創建接口
                            //resultMap = ;
                            break;
                        case "order.cancel":
                            // 單據取消接口
                            //resultMap = ;
                            break;
                        case "singleitem.synchronize":
                            // 商品同步接口
                            //resultMap = ;
                            break;
                        default:
                            resultMap.put("message", "接口名稱method填寫有誤！");
                            resultMap.put("flag", "failure");
                            resultMap.put("code", "500");
                            break;
                    }
                }else {
                    resultMap.put("message", "接口名稱method不能為空！");
                    resultMap.put("flag", "failure");
                    resultMap.put("code", "500");
                }
                result = multilayerMapToXml(resultMap, false).getBytes("UTF-8");
            }else {
                result = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>".getBytes("UTF-8");
            }
        } catch (Exception e) {
            resultMap.put("flag", "failure");
            resultMap.put("code", "500");
            resultMap.put("message", "操作失敗，參數有誤！");
            try {
                result = multilayerMapToXml(resultMap, false).getBytes("UTF-8");
            } catch (UnsupportedEncodingException e1) {
                return null;
            }
        }
        return result;
    }

    /**
     * xml字符串轉json字符串
     * @param xml
     * @return
     */
    private Object xmlForJson(String xml) {
        XMLSerializer xmlSerializer = new XMLSerializer();
        String resutStr = xmlSerializer.read(xml).toString();
        return resutStr;
    }
    
    /**
     * (多層)map轉換為xml格式字符串
     *
     * @param map 需要轉換為xml的map
     * @param isCDATA 是否加入CDATA標識符 true:加入 false:不加入
     * @return xml字符串
     * @throws UnsupportedEncodingException 
     */
    public static String multilayerMapToXml(Map<String, Object> map, boolean isCDATA) throws UnsupportedEncodingException{
        String parentName = "response";
        Document doc = DocumentHelper.createDocument();
        doc.addElement(parentName);
        String xml = recursionMapToXml(doc.getRootElement(), parentName, map, isCDATA);
        return formatXML(xml);
    }

    /**
     * multilayerMapToXml核心方法，遞歸調用
     *
     * @param element 節點元素
     * @param parentName 根元素屬性名
     * @param map 需要轉換為xml的map
     * @param isCDATA 是否加入CDATA標識符 true:加入 false:不加入
     * @return xml字符串
     */
    @SuppressWarnings("unchecked")
    private static String recursionMapToXml(Element element, String parentName, Map<String, Object> map, boolean isCDATA) {
        Element xmlElement = element.addElement(parentName);
        map.keySet().forEach(key -> {
            Object obj = map.get(key);
            if (obj instanceof Map) {
                recursionMapToXml(xmlElement, key, (Map<String, Object>)obj, isCDATA);
            } else {
                String value = obj == null ? "" : obj.toString();
                if (isCDATA) {
                    xmlElement.addElement(key).addCDATA(value);
                } else {
                    xmlElement.addElement(key).addText(value);
                }
            }
        });
        return xmlElement.asXML();
    }
    
    /**
     * 格式化xml,顯示為容易看的XML格式
     *
     * @param xml 需要格式化的xml字符串
     * @return
     */
    public static String formatXML(String xml) {
        String requestXML = null;
        try {
            // 拿取解析器
            SAXReader reader = new SAXReader();
            Document document = reader.read(new StringReader(xml));
            if (null != document) {
                StringWriter stringWriter = new StringWriter();
                // 格式化,每一級前的空格
                OutputFormat format = new OutputFormat("    ", true);
                // xml聲明與內容是否添加空行
                format.setNewLineAfterDeclaration(false);
                // 是否設置xml聲明頭部
                format.setSuppressDeclaration(false);
                // 是否分行
                format.setNewlines(true);
                XMLWriter writer = new XMLWriter(stringWriter, format);
                writer.write(document);
                writer.flush();
                writer.close();
                requestXML = stringWriter.getBuffer().toString();
            }
            return requestXML;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
}