后端在写对外的API接口时，一般会对参数进行签名来保证接口的安全性，在设计签名算法的时候，主要考虑的是这几个问题：

1. 请求的来源是否合法
2. 请求参数是否被篡改
3. 请求的唯一性
   我们的签名加密也是主要针对这几个问题来实现

思路：

1. 生成签名

A调用B应用接口时，将请求参数转换为map进行生成签名（需将工具类及秘钥提供给B）
为保证签名不被篡改及重复使用，根据参数排序生成字符串，加入时间戳，使用私钥进行加密生成起签名sign，将sign和时间戳作为参数传递给B应用
即参数不一样，请求时间不一样，签名即不一样，保证签名唯一。
且私钥不在网络中传输，保证参数合法且不被篡改。
当有多个应用时，应使用APPID区分每个应用的私钥

2. 校验签名

B开放API接口不做权限拦截，做签名校验拦截
根据时间戳及签名sign做检验
根据参数（不含sign）及私钥做签名校验

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * Created by wangqichang on 2018/11/28.
 */
public class SignatureUtil {

    private static String TIME_STAMP_KEY = "timeStamp";
    private static String SIGN_KEY = "sign";
    //超时时效，超过此时间认为签名过期
    private static Long EXPIRE_TIME = 5 * 60 * 1000L;

    /**
     * 生成签名
     *
     * @param param     向VIP发送的参数
     * @param secretKey 由VIP提供的私钥，该私钥应存储于properties方便更换
     * @return
     */
    public static Map getSignature(Object param, String secretKey) {
        ObjectMapper objectMapper = new ObjectMapper();
        Map params;
        try {
            String jsonStr = objectMapper.writeValueAsString(param);
            params = objectMapper.readValue(jsonStr, Map.class);

        } catch (Exception e) {
            throw new RuntimeException("生成签名：转换json失败");
        }

        if (params.get(TIME_STAMP_KEY) == null) {
            params.put(TIME_STAMP_KEY, System.currentTimeMillis());
        }
        //对map参数进行排序生成参数
        Set<String> keysSet = params.keySet();
        Object[] keys = keysSet.toArray();
        Arrays.sort(keys);
        StringBuilder temp = new StringBuilder();
        boolean first = true;
        for (Object key : keys) {
            if (first) {
                first = false;
            } else {
                temp.append("&");
            }
            temp.append(key).append("=");
            Object value = params.get(key);
            String valueString = "";
            if (null != value) {
                valueString = String.valueOf(value);
            }
            temp.append(valueString);
        }
        //根据参数生成签名
        String sign = DigestUtils.sha256Hex(temp.toString() + secretKey).toUpperCase();
        params.put(SIGN_KEY, sign);
        return params;
    }

    /**
     * 校验签名有效性
     *
     * @param request   core向VIP发起的请求
     * @param secretKey VIP提供的私钥
     * @return
     */
    public static boolean checkSignature(HttpServletRequest request, String secretKey) {
        //获取request中的json参数转成map
        Map<String, Object> param = new HashMap<>();
        try {
            BufferedReader streamReader = new BufferedReader(new InputStreamReader(request.getInputStream(), "UTF-8"));
            StringBuilder responseStrBuilder = new StringBuilder();
            String inputStr;
            while ((inputStr = streamReader.readLine()) != null) {
                responseStrBuilder.append(inputStr);
            }
            ObjectMapper objectMapper = new ObjectMapper();
            param = objectMapper.readValue(responseStrBuilder.toString(), Map.class);
        } catch (IOException e) {
            return false;
        }
        String sign = (String) param.get(SIGN_KEY);
        Long start = (Long) param.get(TIME_STAMP_KEY);
        long now = System.currentTimeMillis();
        //校验时间有效性
        if (start == null || now - start > EXPIRE_TIME || start - now > 0L) {
            return false;
        }
        //是否携带签名
        if (StringUtils.isBlank(sign)) {
            return false;
        }
        //获取除签名外的参数
        param.remove(SIGN_KEY);
        //校验签名
        Map paramMap = SignatureUtil.getSignature(param, secretKey);
        String signature = (String) paramMap.get("sign");
        if (sign.equals(signature)) {
            return true;
        }
        return false;
    }

}