springboot入參和出參加密解密-后端and前端

1.定义过滤器对入参进行加密 DecryptFilter.java

package com.xikang.common.filter;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xikang.common.filter.DecryptionRequestWrapper;
import com.xikang.common.utils.AES;
import com.xikang.common.utils.AESCipher;
import com.xikang.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.util.AntPathMatcher;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;

/**
 * @author: sun
 * @date: 2023/4/10
 */

@Slf4j
@Order(-1)
@Configuration
@WebFilter(urlPatterns = "/*", filterName = "DecryptFilter")
public class DecryptFilter implements Filter {
    //不需要加密的接口
    @Value("${ignored.urls}")
    private String[] ignoredUrls;
    //xikang  通过 AESUtils 中key方法生成而来
    private static final String KEY = "cxikangbef1075OD";

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest) request);

        String method = request.getMethod();
        String url = request.getRequestURI();
        Boolean flag = false;

        String contentType = request.getContentType();

        //判断是否是静态资源
        if (isStaticResource(url)) {
            flag = true;
        } else{
            url = url.split("\\?")[0];
            AntPathMatcher pathMatcher = new AntPathMatcher();
            for (String ignoredUrl : ignoredUrls) {
                flag = pathMatcher.match(ignoredUrl, url);
                if (flag) {
                    break;
                }
            }
        }
        if (!flag) {
            // 该方法处理 POST请求并且contentType为application/json格式的
            if ("POST".equals(method) && StringUtils.isNotEmpty(contentType)&& contentType.contains(MediaType.APPLICATION_JSON_VALUE)) {
                String str = new String(requestWrapper.getBody());
                if (StringUtils.isNotEmpty(str)) {
                    //post请求内容需要解密
                    str = AESCipher.de(str,KEY);
                    JSONObject jsonObject = JSONObject.parseObject(str);
                    String bodyStr = jsonObject.get("body").toString();
                    requestWrapper.setBody(bodyStr.getBytes(StandardCharsets.UTF_8));
                }
                // 继续处理请求
                chain.doFilter(requestWrapper, response);
            }else{
                Map<String, String[]> parameterMap = servletRequest.getParameterMap();
                //单点登录不用解密直接放行，，，（没办法的办法）
                if (parameterMap.containsKey("auth")) {
                    chain.doFilter(servletRequest, response);
                }
                Map<String, String[]> decryptedParameterMap = new HashMap<>();
                if (parameterMap.size() > 0) {
                    if (!flag) {
                        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
                        if (method.equals("GET")) {
                            for (Map.Entry<String, String[]> entry : entries) {
                                String[] value = entry.getValue();
                                String decryptedValues = "";
                                try {
                                    decryptedValues = AESCipher.de(value[0], KEY);
                                    if(!"{}".equals(decryptedValues)){
                                        setParameterMap(decryptedParameterMap, decryptedValues);
                                    }
                                } catch (Exception e) {
                                    log.error("参数解密出错" + url + "================" + e.getMessage(), e);
                                }

                            }
                        }

                        if (method.equals("POST") || method.equals("PUT")) {
                            for (String key : parameterMap.keySet()) {
                                if("auth".equals(key)){
                                    break;
                                }
                                String decryptedValues = "";
                                try {
                                    decryptedValues = AESCipher.de(key, KEY);
                                } catch (Exception e) {
                                    log.error("参数解密出错" + url + "================" + e.getMessage(), e);
                                }
                                setPostParameterMap(decryptedParameterMap, decryptedValues);
                            }
                        }


                        HttpServletRequest httpRequest = request;
                        // 将解密后的参数设置回请求中
                        DecryptionRequestWrapper decryptionRequestWrapper = new DecryptionRequestWrapper(httpRequest, decryptedParameterMap);

                        // 继续处理请求
                        chain.doFilter(decryptionRequestWrapper, response);
                    }
                }else{
                    chain.doFilter(servletRequest, response);
                }
            }
            }else {
            chain.doFilter(servletRequest, response);
        }



    }

    private void setPostParameterMap(Map<String, String[]> decryptedParameterMap, String decryptedValues) {
        getJsonObject(decryptedParameterMap, decryptedValues);
    }

    private void getJsonObject(Map<String, String[]> decryptedParameterMap, String decryptedValues) {
        JSONObject jsonObject = JSONObject.parseObject(decryptedValues);
        if (Objects.nonNull(jsonObject)) {
            if (jsonObject.size() > 0) {
                String body = jsonObject.getString("body");
                if (body.startsWith("[")) {
                    String[] params = new String[1];
                    params[0] = body;
                    decryptedParameterMap.put("param", params);
                } else {
                    JSONObject parseObject = JSONObject.parseObject(body);
                    Set<String> strings = parseObject.keySet();
                    for (String string : strings) {
                        String[] params = new String[1];
                        params[0] = parseObject.getString(string);
                        //数组参数处理
                        if (params[0].contains("[")) {
                            String[] res = JSONObject.parseObject(params[0], String[].class);
                            decryptedParameterMap.put(string, res);
                        } else {
                            decryptedParameterMap.put(string, params);
                        }
                    }
                }


            }
        }

    }

    private void setParameterMap(Map<String, String[]> decryptedParameterMap, String decryptedValues) {
        getJsonObject(decryptedParameterMap, decryptedValues);
    }

    @Override
    public void destroy() {

    }


    private Set<String> staticResourceTypes = new HashSet<String>();

    {
        staticResourceTypes.add(".html");
        staticResourceTypes.add(".css");
        staticResourceTypes.add(".js");
        staticResourceTypes.add(".png");
        staticResourceTypes.add(".jpg");
        staticResourceTypes.add(".otf");
        staticResourceTypes.add(".eot");
        staticResourceTypes.add(".svg");
        staticResourceTypes.add(".ttf");
        staticResourceTypes.add(".woff");
        staticResourceTypes.add(".gif");
        staticResourceTypes.add(".ico");
        staticResourceTypes.add(".txt");
        staticResourceTypes.add(".gzip");
        staticResourceTypes.add(".xz");
        staticResourceTypes.add(".tar.gz");
        staticResourceTypes.add(".tar.bz2");
        staticResourceTypes.add(".jar");
        staticResourceTypes.add(".war");
        staticResourceTypes.add(".7z");
        staticResourceTypes.add(".tgz");
        staticResourceTypes.add(".gz");
        staticResourceTypes.add(".map");

    }

    public final boolean isStaticResource(String url) {

        boolean result = false;
        if (org.apache.commons.lang3.StringUtils.isBlank(url)) {
            return result;
        }
        int start = url.lastIndexOf(".");
        if (start < 0) {
            return result;
        }
        String prex = url.substring(start, url.length());
        return staticResourceTypes.contains(prex);
    }
}

2.定义Wrapper 操作request参数 用于解密后重新放入RequestWrapper.java

package com.xikang.common.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

/**
 * @author xikang
 * @createTime 2023年04月08日
 */
@Slf4j
public class RequestWrapper extends HttpServletRequestWrapper {

    private Map<String, String[]> params = new HashMap<>();

    private byte[] body;

    public RequestWrapper(HttpServletRequest request) {
        super(request);
        body = getBodyString(request).getBytes(StandardCharsets.UTF_8);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        this.params.putAll(request.getParameterMap());
    }

    public RequestWrapper(HttpServletRequest request, Map<String, String[]> parameterMap) {
        super(request);
        this.params = parameterMap;
    }


    /**
     * 在获取所有的参数名,必须重写此方法，否则对象中参数值映射不上
     *
     * @return
     */
    @Override
    public Enumeration<String> getParameterNames() {
        return new Vector<>(params.keySet()).elements();
    }

    /**
     * 重写getParameter方法
     *
     * @param name 参数名
     * @return 返回参数值
     */
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return new String[]{};
        }
        return values;
    }

    /**
     * 增加多个参数
     *
     * @param otherParams 增加的多个参数
     */
    public void addAllParameters(Map<String, Object> otherParams) {
        for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    /**
     * 增加参数
     *
     * @param name  参数名
     * @param value 参数值
     */
    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }


    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * 重写获取 输入流的方法，保证流可写可读多次
     *
     * @return ServletInputStream
     * @throws IOException IO异常
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bs = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
                log.info(readListener.toString());
            }

            @Override
            public int read() throws IOException {
                return bs.read();
            }
        };
    }

    public byte[] getBody() {
        return body;
    }

    public void setBody(byte[] body) {
        this.body = body;
    }

    public static String getBodyString(ServletRequest request) {
        StringBuilder sb = new StringBuilder();
        try (
                InputStream inputStream = request.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            log.error("getBodyString IOException", e);
        }
        return sb.toString();
    }
}

3.加密解密AESClipher.java

package com.xikang.common.utils;


import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Random;

/**
 * @author: sun
 * @date: 2023/4/8
 **/
public class AESCipher {
    private static final String IV_STRING = "bef1075ODfADd5ac";
    private static final String charset = "UTF-8";

    public static String en(String content, String key) {
        try {
            byte[] contentBytes = content.getBytes(charset);
            byte[] keyBytes = key.getBytes(charset);
            byte[] encryptedBytes = aesEncryptBytes(contentBytes, keyBytes);
            Base64.Encoder encoder = Base64.getEncoder();

            return encoder.encodeToString(encryptedBytes);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String de(String content, String key)  {
        try {
            Base64.Decoder decoder = Base64.getDecoder();
            byte[] encryptedBytes = decoder.decode(content.replaceAll(" ","+"));
            byte[] keyBytes = key.getBytes(charset);
            byte[] decryptedBytes = aesDecryptBytes(encryptedBytes, keyBytes);
            return new String(decryptedBytes, charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static byte[] aesEncryptBytes(byte[] contentBytes, byte[] keyBytes)  {
        return cipherOperation(contentBytes, keyBytes, Cipher.ENCRYPT_MODE);
    }

    public static byte[] aesDecryptBytes(byte[] contentBytes, byte[] keyBytes) {
        return cipherOperation(contentBytes, keyBytes, Cipher.DECRYPT_MODE);
    }

    private static byte[] cipherOperation(byte[] contentBytes, byte[] keyBytes, int mode) {

        try {
            SecretKeySpec secretKey = new SecretKeySpec(keyBytes, "AES");
            byte[] initParam = IV_STRING.getBytes(charset);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(initParam);

            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(mode, secretKey, ivParameterSpec);

            return cipher.doFinal(contentBytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }


    public static String getKey() {
        String uuid = "xikang";
        StringBuffer buff = new StringBuffer();
        buff.append(uuid).append(IV_STRING).append(uuid).append(IV_STRING);
        Random random = new Random();
        int start = random.nextInt(buff.length());
        int end = (start + 16) < buff.length() ? start + 16 : start - 16;
        if (end > start) {
            return buff.substring(start, end);
        }
        return buff.substring(end, start);
    }
    public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
        for (int i = 0; i < 100; i++) {
            String key=getKey();
            System.out.println(key.length()+"key:"+getKey());
        }
//        String string = AESCipher.en("{\"version\":\"2\",\"uri\":\"/pharmacyapi/xk/pharmacy/order/getLogisticsList\",\"method\":\"POST\",\"params\":{\"page\":1,\"row\":10,\"mechanismId\":\"4\",\"name\":null,\"orderNumber\":null,\"rxIdStr\":\"\",\"takeMedicineCode\":null,\"takeMedicineType\":0,\"distributionStatus\":5}}", "5ODfADd5acbc6e4d");
//        System.out.println(string);
//        System.out.println(AESCipher.de("i5tjUv3RgxLVn8907L1vNS/o0g4lpfGhRBeVTjCI7jAX4Ya59W1zyUR5sGDt4IHOJIsmbEYL1k3Iq2elTrzffJgqJ5LCWAnwloGFslvyDiv2+TPcVnLUOux+xrySdWMoDv+my3nmy9rv7IAs4uokDRMXeZrYqF5+6acoTjZ77Dc=", "4f586c672f1a9bef"));
        System.out.println(AESCipher.de("UyCOlIR3aGYe+RgA6XrjUHg/U6Fb/FjnXbAWt+1cnHwL4eHA8LNUDckv3mN53CKHcWFNHdCIQq9lEcujLKRCqaJP5PRvI83BarxxbwdUeL7U+0heofcJZDu/8TOlKiJM+4nJYb56Cfuhsn7T00JMGJlJtrU0qBNDrHBFi6zFx8c=", "FDS84dd7c104d0XK"));
    }
}

4.commmonUtils.java

package com.xikang.common.utils;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * @author tc 2018年8月27日上午9:31:28
 * @description 工具类
 */
public class CommonUtils {

    /**
     * 将 URL 进行BASE64转码
     *
     * @param originString
     * @return
     */
    public static String encryptBASE64(String originString) {
        return encryptBASE64(originString.getBytes());
    }

    /**
     * 将 URL 进行BASE64转码
     *
     * @param
     * @return
     */
    public static String encryptBASE64(byte[] bytes) {
        return new BASE64Encoder().encode(bytes);
    }

    /**
     * 将 URL 进行BASE64解码
     *
     * @param originString
     * @return
     */
    public static String decodeBASE64(String originString) {
        try {
            return new String(new BASE64Decoder().decodeBuffer(originString));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
}

5.出参加密

package com.xikang.common.utils;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * @author tc 2018年8月27日上午9:31:28
 * @description 工具类
 */
public class CommonUtils {

    /**
     * 将 URL 进行BASE64转码
     *
     * @param originString
     * @return
     */
    public static String encryptBASE64(String originString) {
        return encryptBASE64(originString.getBytes());
    }

    /**
     * 将 URL 进行BASE64转码
     *
     * @param
     * @return
     */
    public static String encryptBASE64(byte[] bytes) {
        return new BASE64Encoder().encode(bytes);
    }

    /**
     * 将 URL 进行BASE64解码
     *
     * @param originString
     * @return
     */
    public static String decodeBASE64(String originString) {
        try {
            return new String(new BASE64Decoder().decodeBuffer(originString));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }
}

前端

1.aes.js

import CryptoJS from "crypto-js";
export function Encrypt(key = 'cxikangbef1075OD', iv ='bef1075ODfADd5ac', word) {
  key = CryptoJS.enc.Utf8.parse(key);
  iv = CryptoJS.enc.Utf8.parse(iv);
  let srcs = CryptoJS.enc.Utf8.parse(word);
  // 加密模式为CBC，补码方式为PKCS5Padding（也就是PKCS7）
  let encrypted = CryptoJS.AES.encrypt(srcs, key, {
    iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
  });
  //返回base64
  return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);
}
export function Decrypt(key= 'cxikangbef1075OD', iv ='bef1075ODfADd5ac', word) {
  key = CryptoJS.enc.Utf8.parse(key);
  iv = CryptoJS.enc.Utf8.parse(iv);
  let base64 = CryptoJS.enc.Base64.parse(word);
  let src = CryptoJS.enc.Base64.stringify(base64);
  // 解密模式为CBC，补码方式为PKCS5Padding（也就是PKCS7）
  let decrypt = CryptoJS.AES.decrypt(src, key, {
    iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7
  });
  let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
  return decryptedStr.toString();
}

2request.js

import axios from 'axios'
import {Loading, Message, MessageBox, Notification} from 'element-ui'
import store from '@/store'
import {getToken} from '@/utils/auth'
import errorCode from '@/utils/errorCode'
import {Decrypt, Encrypt} from '@/plugins/aes'
import {blobValidate, isJSON, tansParams} from "@/utils/xikang";
import {saveAs} from 'file-saver'

let downloadLoadingInstance;
// 是否显示重新登录
let isReloginShow;

axios.defaults.headers['Content-Type'] = 'application/json;charset=utf-8'
// 创建axios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  baseURL: process.env.VUE_APP_BASE_API,
  // 超时
  timeout: 10000
})

// request拦截器
service.interceptors.request.use(config => {
  // 是否需要设置 token
  const isToken = (config.headers || {}).isToken === false
  // 是否需要防止数据重复提交
  const isRepeatSubmit = (config.headers || {}).repeatSubmit === false
  if (getToken() && !isToken) {
    config.headers['Authorization'] = 'Bearer ' + getToken() // 让每个请求携带自定义token 请根据实际情况自行修改
  }

  // 单点登录跳转不加密
  if (config.params && config.params.hasOwnProperty('auth')) {
    return config
  }

  if (config.method.toUpperCase() === 'GET' || config.method.toUpperCase() === 'DELETE') {
    let data = { body: config.params }
    config.params = Encrypt(undefined, undefined, JSON.stringify(data))
  } else {
    let data = { body: config.data }
    config.data = Encrypt(undefined, undefined, JSON.stringify(data))
  }


  // get请求映射params参数
  // if (config.method === 'get' && config.params) {
  //   let url = config.url + '?' + tansParams(config.params);
  //   url = url.slice(0, -1);
  //   config.url = url;
  // }
  // if (!isRepeatSubmit && (config.method === 'post' || config.method === 'put')) {
  //   const requestObj = {
  //     url: config.url,
  //     data: typeof config.data === 'object' ? JSON.stringify(config.data) : config.data,
  //     time: new Date().getTime()
  //   }
  //   const sessionObj = cache.session.getJSON('sessionObj')
  //   if (sessionObj === undefined || sessionObj === null || sessionObj === '') {
  //     cache.session.setJSON('sessionObj', requestObj)
  //   } else {
  //     const s_url = sessionObj.url;                  // 请求地址
  //     const s_data = sessionObj.data;                // 请求数据
  //     const s_time = sessionObj.time;                // 请求时间
  //     const interval = 1000;                         // 间隔时间(ms)，小于此时间视为重复提交
  //     if (s_data === requestObj.data && requestObj.time - s_time < interval && s_url === requestObj.url) {
  //       const message = '数据正在处理，请勿重复提交';
  //       console.warn(`[${s_url}]: ` + message)
  //       return Promise.reject(new Error(message))
  //     } else {
  //       cache.session.setJSON('sessionObj', requestObj)
  //     }
  //   }
  // }
  return config
}, error => {
    console.log(error)
    Promise.reject(error)
})

// 响应拦截器
service.interceptors.response.use(res => {
    // 接口加密
    let decrypData = res.data.data
    // 如果有rows解密数据塞给rows,否则解密数据塞给data
    if (decrypData) {
      if (res.data.hasOwnProperty('rows')) {
        if (isJSON(Decrypt(undefined, undefined, decrypData))) {
          // 处理解析后的数据
          res.data.rows = JSON.parse(Decrypt(undefined, undefined, decrypData))
        } else {
          // 处理解析失败的情况
          res.data.rows = Decrypt(undefined, undefined, decrypData)
        }
      } else {
        if (isJSON(Decrypt(undefined, undefined, decrypData))) {
          // 处理解析后的数据
          res.data.data = JSON.parse(Decrypt(undefined, undefined, decrypData))
        } else {
          // 处理解析失败的情况
          res.data.data = Decrypt(undefined, undefined, decrypData)
        }
      }
    }
    // 未设置状态码则默认成功状态
    const code = res.data.code || 200;
    // 获取错误信息
    const msg = errorCode[code] || res.data.msg || errorCode['default']
    // 二进制数据则直接返回
    if(res.request.responseType ===  'blob' || res.request.responseType ===  'arraybuffer'){
      return res.data
    }

    if (code === 401) {
      if (!isReloginShow) {
        isReloginShow = true;
        MessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', {
          confirmButtonText: '重新登录',
          cancelButtonText: '取消',
          type: 'warning'
        }
      ).then(() => {
        isReloginShow = false;
        store.dispatch('LogOut').then(() => {
          // 如果是登录页面不需要重新加载
          if (window.location.hash.indexOf("#/login") !== 0) {
            location.href = '/kpi/index';
          }
        })
      }).catch(() => {
        isReloginShow = false;
      });
    }
      return Promise.reject('无效的会话，或者会话已过期，请重新登录。')
    } else if (code === 500) {
      Message({
        message: msg,
        type: 'error'
      })
      return Promise.reject(new Error(msg))
    } else if (code !== 200) {
      Notification.error({
        title: msg
      })
      return Promise.reject('error')
    } else {
      return res.data
    }
  },
  error => {
    console.log('err' + error)
    let { message } = error;
    if (message === "Network Error") {
      message = "后端接口连接异常";
    }
    else if (message.includes("timeout")) {
      message = "系统接口请求超时";
    }
    else if (message.includes("Request failed with status code")) {
      message = "系统接口" + message.substr(message.length - 3) + "异常";
    }
    Message({
      message: message,
      type: 'error',
      duration: 5 * 1000
    })
    return Promise.reject(error)
  }
)

// 通用下载方法
export function download(url, params, filename) {
  downloadLoadingInstance = Loading.service({ text: "正在下载数据，请稍候", spinner: "el-icon-loading", background: "rgba(0, 0, 0, 0.7)", })
  return service.post(url, params, {
    transformRequest: [(params) => { return tansParams(params) }],
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    responseType: 'blob'
  }).then(async (data) => {
    const isLogin = await blobValidate(data);
    if (isLogin) {
      const blob = new Blob([data])
      saveAs(blob, filename)
    } else {
      const resText = await data.text();
      const rspObj = JSON.parse(resText);
      const errMsg = errorCode[rspObj.code] || rspObj.msg || errorCode['default']
      Message.error(errMsg);
    }
    downloadLoadingInstance.close();
  }).catch((r) => {
    console.error(r)
    Message.error('下载文件出现错误，请联系管理员！')
    downloadLoadingInstance.close();
  })
}

export default service

3.xikang.js

/**
 * 通用js方法封装处理
 * Copyright (c) 2019 xikang
 */

// 日期格式化
export function parseTime(time, pattern) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    if ((typeof time === 'string') && (/^[0-9]+$/.test(time))) {
      time = parseInt(time)
    } else if (typeof time === 'string') {
      time = time.replace(new RegExp(/-/gm), '/').replace('T', ' ').replace(new RegExp(/\.[\d]{3}/gm), '');
    }
    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value] }
    if (result.length > 0 && value < 10) {
      value = '0' + value
    }
    return value || 0
  })
  return time_str
}

// 表单重置
export function resetForm(refName) {
  if (this.$refs[refName]) {
    this.$refs[refName].resetFields();
  }
}

// 添加日期范围
export function addDateRange(params, dateRange, propName) {
  let search = params;
  search.params = typeof (search.params) === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {};
  dateRange = Array.isArray(dateRange) ? dateRange : [];
  if (typeof (propName) === 'undefined') {
    search.params['beginTime'] = dateRange[0];
    search.params['endTime'] = dateRange[1];
  } else {
    search.params['begin' + propName] = dateRange[0];
    search.params['end' + propName] = dateRange[1];
  }
  return search;
}

// 回显数据字典
export function selectDictLabel(datas, value) {
  var actions = [];
  Object.keys(datas).some((key) => {
    if (datas[key].dictValue == ('' + value)) {
      actions.push(datas[key].dictLabel);
      return true;
    }
  })
  return actions.join('');
}
// 回显数据字典（字符串数组）
export function selectDictLabels(datas, value, separator) {
  if(value === undefined) {
    return "";
  }
  var actions = [];
  var currentSeparator = undefined === separator ? "," : separator;
  var temp = value.split(currentSeparator);
  Object.keys(value.split(currentSeparator)).some((val) => {
    Object.keys(datas).some((key) => {
      if (datas[key].value == ('' + temp[val])) {
        actions.push(datas[key].label + currentSeparator);
      }
    })
  })
  return actions.join('').substring(0, actions.join('').length - 1);
}

// 字符串格式化(%s )
export function sprintf(str) {
  var args = arguments, flag = true, i = 1;
  str = str.replace(/%s/g, function () {
    var arg = args[i++];
    if (typeof arg === 'undefined') {
      flag = false;
      return '';
    }
    return arg;
  });
  return flag ? str : '';
}

// 转换字符串，undefined,null等转化为""
export function parseStrEmpty(str) {
  if (!str || str == "undefined" || str == "null") {
    return "";
  }
  return str;
}

// 数据合并
export function mergeRecursive(source, target) {
  for (var p in target) {
    try {
      if (target[p].constructor == Object) {
        source[p] = mergeRecursive(source[p], target[p]);
      } else {
        source[p] = target[p];
      }
    } catch (e) {
      source[p] = target[p];
    }
  }
  return source;
};

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 */
export function handleTree(data, id, parentId, children) {
  let config = {
    id: id || 'id',
    parentId: parentId || 'parentId',
    childrenList: children || 'children'
  };

  var childrenListMap = {};
  var nodeIds = {};
  var tree = [];

  for (let d of data) {
    let parentId = d[config.parentId];
    if (childrenListMap[parentId] == null) {
      childrenListMap[parentId] = [];
    }
    nodeIds[d[config.id]] = d;
    childrenListMap[parentId].push(d);
  }

  for (let d of data) {
    let parentId = d[config.parentId];
    if (nodeIds[parentId] == null) {
      tree.push(d);
    }
  }

  for (let t of tree) {
    adaptToChildrenList(t);
  }

  function adaptToChildrenList(o) {
    if (childrenListMap[o[config.id]] !== null) {
      o[config.childrenList] = childrenListMap[o[config.id]];
    }
    if (o[config.childrenList]) {
      for (let c of o[config.childrenList]) {
        adaptToChildrenList(c);
      }
    }
  }
  return tree;
}

/**
* 参数处理
* @param {*} params  参数
*/
export function tansParams(params) {
  let result = ''
  for (const propName of Object.keys(params)) {
    const value = params[propName];
    var part = encodeURIComponent(propName) + "=";
    if (value !== null && typeof (value) !== "undefined") {
      if (typeof value === 'object') {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && typeof (value[key]) !== 'undefined') {
            let params = propName + '[' + key + ']';
            var subPart = encodeURIComponent(params) + "=";
            result += subPart + encodeURIComponent(value[key]) + "&";
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&";
      }
    }
  }
  return result
}

// 验证是否为blob格式
export async function blobValidate(data) {
  try {
    const text = await data.text();
    JSON.parse(text);
    return false;
  } catch (error) {
    return true;
  }
}

// 判断字符串是否可以用 JSON.parse
export function isJSON(str) {
  try {
    JSON.parse(str);
    return true;
  } catch (e) {
    return false;
  }
}