URL入参出参请求头可配置化

最新推荐文章于 2024-08-05 03:53:25 发布
最新推荐文章于 2024-08-05 03:53:25 发布
阅读量306 收藏
点赞数 3
分类专栏： 开发小技巧 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meser88/article/details/138857768
版权

整体思路

通过spring的Spell表达式解析变量的参数值，参数名定义为${XXX},在解析参数值后，将${XXX}替换成#XXX以匹配Spell表达式。

核心实现类

package com.example.spring_boot_study.spring.spell;

import cn.hutool.core.map.MapUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.Method;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.example.spring_boot_study.SpringEl.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Component;
import org.springframework.util.PropertyPlaceholderHelper;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
@Component
public class DynamicUrlDemo {

    private static final String VAR_PREFIX = "${";
    private static final String VAR_SUFFIX = "}";
    private static final String POINT = ".";
    private static final String EQUAL = "=";
    private static final String WELL = "#";
    // 将表达式中含有多个${XXX}的进行分组，拿到所有参数名(如${XXX}+${YYY})
    // 正则的含义是匹配${开始，非}字符的N个字符，其中以非}字符的N个字符作为分组，即分组为XXX和YYY
    private static final Pattern VAR_PATTERN = Pattern.compile("\\$\\{([^}]*)");

    private final PropertyPlaceholderHelper placeholderHelper =
            new PropertyPlaceholderHelper(VAR_PREFIX, VAR_SUFFIX);
    private final ExpressionParser parser = new SpelExpressionParser(SpringElUtil.CONFIG);

    // 允许为空的参数
    @Value("${valueMayBeEmptyParams:a,b,c}")
    private String valueMayBeEmptyParams;

    public void handle(RequestDemo requestDemo, JSONObject msgJson) {
        String url = requestDemo.getUrl();
        Map<String, Object> delayHeaders = new HashMap<>(2);
        // 解析URL里包含的变量${XXX}
        url = placeholderHelper.replacePlaceholders(url, variable -> {
            VariableParser variableParser = VariableParseSelector.selectParser(variable);
            if (variableParser == null) {
                throw new RuntimeException(variable + "没有对应的参数解析器");
            }
            Object object = variableParser.parseVariable(variable, msgJson);
            return String.valueOf(object);
        });

        try {
            // 1、构建请求头
            String requestHeader = requestDemo.getRequestHeader();
            Map<String, String> headers = new HashMap<>(4);
            if (StringUtils.isNotEmpty(requestHeader)) {
                JSONObject requestHeaderJson = JSON.parseObject(requestHeader);
                // 移除需要在解析完body后执行解析的头部字段 延后执行
                // (即requestBody是所有入参的摘要算法结果，有些请求为了安全可能要对所有入参做一个摘要算法)
                requestHeaderJson.entrySet().removeIf(header -> {
                    if (header.getValue().toString().contains("${requestBody}")) {
                        delayHeaders.put(header.getKey(), header.getValue());
                        return true;
                    }
                    return false;
                });
                headers = buildHeaders(requestHeaderJson, msgJson);
            }

            String responseStr;
            String requestConfig = requestDemo.getRequestConfig();
            Object object = JSON.parse(requestConfig);
            HttpRequest httpRequest = HttpRequest.of(url).addHeaders(headers).timeout(10000);
            if (object instanceof JSONObject) {
                // 2、构建请求参数
                JSONObject requestJson = (JSONObject) object;
                Map<String, Object> form = parseParams(requestJson, msgJson);

                // 写入${requestBody}
                if (!delayHeaders.isEmpty()) {
                    msgJson.put("requestBody", new JSONArray(Collections.singletonList(form)).toJSONString());
                    httpRequest.addHeaders(buildHeaders(new JSONObject(delayHeaders), msgJson));
                }

                // 3、执行请求
                if (RequestType.GET.getTypeCode() == requestDemo.getRequestType()) {
                    responseStr = httpRequest.method(Method.GET).form(form).execute().body();
                } else {
                    String header = httpRequest.header("Content-Type");
                    if (header != null && header.contains("application/json")) {
                        responseStr = httpRequest.method(Method.POST).body(JSON.toJSONString(form)).execute().body();
                    } else {
                        responseStr = httpRequest.method(Method.POST).form(form).execute().body();
                    }
                }
            } else if (object instanceof JSONArray) {
                JSONArray jsonArray = (JSONArray) object;
                List<Map<String, Object>> form = new ArrayList<>(jsonArray.size());
                jsonArray.forEach(obj -> form.add(parseParams((JSONObject) obj, msgJson)));

                // 写入${requestBody}
                if (!delayHeaders.isEmpty()) {
                    httpRequest.addHeaders(buildHeaders(new JSONObject(delayHeaders), msgJson));
                }

                // 3、执行请求
                if (RequestType.GET.getTypeCode() == requestDemo.getRequestType()) {
                    responseStr = httpRequest.method(Method.GET).body(JSON.toJSONString(form)).execute().body();
                } else {
                    responseStr = httpRequest.method(Method.POST).body(JSON.toJSONString(form)).execute().body();
                }
            } else {
                log.error("无法解析请求参数配置：{}", requestConfig);
                return;
            }

            String responseConfig = requestDemo.getResponseConfig();
            // 如果需要对调用结果进行处理，如落库等，则另外用一个策略模式对url进行相应处理
            // 跟参数解析器一样，不过以url为key
            if (checkReportResult(responseStr, responseConfig)) {
                log.info("请求[{}]成功", url);
            } else {
                log.info("请求[{}]失败", url);
            }
        } catch (Exception e) {
            log.error("请求[{}]异常", url);
        }
    }


    /**
     * 解析并构建头部
     */
    private Map<String, String> buildHeaders(JSONObject requestHeaderJson, JSONObject msgJson) {
        Map<String, String> headers = new HashMap<>(4);
        Map<String, Object> headerParamMap = parseParams(requestHeaderJson, msgJson);
        if (MapUtil.isNotEmpty(headerParamMap)) {
            headerParamMap.forEach((key, value) -> {
                if (value != null && StringUtils.isNoneBlank(value.toString())) {
                    headers.put(key, value.toString());
                }
            });
        }
        return headers;
    }

    /**
     * 解析请求参数，把Json配置转换成Map
     *
     * @param config  入参配置
     * @param msgJson 消息体
     * @return 参数
     */
    private Map<String, Object> parseParams(JSONObject config, JSONObject msgJson) {
        Map<String, Object> paramMap = new HashMap<>(config.size());
        EvaluationContext ctx;
        try {
            ctx = SpringElUtil.createContext();
        } catch (NoSuchMethodException e) {
            throw new RuntimeException("创建SpringEL表达式上下文异常。");
        }

        config.forEach((paramKey, paramValueExpress) -> {
            Object key;
            // 字段名也支持表达式 但暂时不打算支持任意位置的，如果以后支持字段名任意位置的表达式 把条件去掉
            if (paramKey.charAt(0) == '$') {
                // 字段名也支持表达式
                key = parseValue(ctx, paramKey, msgJson);
            } else {
                key = paramKey;
            }

            if (paramValueExpress instanceof JSONObject) {
                Map<String, Object> paramValue = parseParams((JSONObject) paramValueExpress, msgJson);
                paramMap.put(String.valueOf(key), paramValue);
            } else if (paramValueExpress instanceof JSONArray) {
                List<Map<String, Object>> paramValueList = new ArrayList<>(((JSONArray) paramValueExpress).size());
                ((JSONArray) paramValueExpress).forEach(
                        subParamValueExpress -> paramValueList.add(parseParams((JSONObject) subParamValueExpress,
                                msgJson)));
                paramMap.put(String.valueOf(key), paramValueList);
            } else {
                try {
                    Object paramValue = parseValue(ctx, paramValueExpress, msgJson);
                    paramMap.put(String.valueOf(key), paramValue);
                    log.info("解析参数[{}]对应的表达式[{}]值为[{}].", key, paramValueExpress, paramValue);
                } catch (Exception e) {
                    log.info("解析参数[{}]对应的表达式[{}]跳过.", key, paramValueExpress);
                }
            }
        });
        return paramMap;
    }


    /**
     * 解析参数值的表达式
     * 逻辑是${XXX}代表参数名，解析完后替换成#XXX以匹配Spring Spell表达式的语法
     * 之所以这么定义，是为了区分#XXX()的方法，更方便解析参数去获取对应的值
     *
     * @param msgJson      消息体
     * @param valueExpress 表达式
     * @return 参数值
     */
    private Object parseValue(EvaluationContext ctx, Object valueExpress, JSONObject msgJson) {
        String varExpress = String.valueOf(valueExpress);
        if (varExpress.contains(VAR_PREFIX) && varExpress.contains(VAR_SUFFIX)) {
            List<String> varList = this.getVariableNames(varExpress);
            for (String varName : varList) {
                if (ctx.lookupVariable(varName) == null) {
                    // 策略模式获取定义参数值
                    VariableParser variableParser = VariableParseSelector.selectParser(varName);
                    if (variableParser == null) {
                        throw new RuntimeException(varName + "找不到对应的变量解析器。");
                    }
                    Object varValue = variableParser.parseVariable(varName, msgJson);
                    if (varName.indexOf(valueMayBeEmptyParams) != -1
                            && (varValue == null
                            || StringUtils.isBlank(varValue.toString()))) {
                        throw new RuntimeException(varName + "解析变量值失败。");
                    }
                    ctx.setVariable(varName, varValue);
                }
                // 将 ${oppoPhoneIdValue} 替换成 #oppoPhoneIdValue，匹配Spell表达式
                varExpress = varExpress.replaceAll("\\$\\{" + varName + "}", "\\#" + varName);

            }
        }
        if (varExpress.contains(WELL)) {
            return parser.parseExpression(varExpress).getValue(ctx);
        } else {
            // 直接赋值的，即写死的参数
            return valueExpress;
        }
    }


    /**
     * 检查请求是否正确
     *
     * @param responseStr    响应体
     * @param responseConfig 响应配置
     * @return 是否成功
     */
    private boolean checkReportResult(String responseStr, String responseConfig) {
        try {
            if (responseConfig.contains(EQUAL)) {
                String[] configs = StringUtils.split(responseConfig, EQUAL);
                String resultKey = configs[0];
                String expectValue = configs[1];
                String[] keys = StringUtils.split(resultKey, POINT);
                String resultValue = getResultValue(JSON.parseObject(responseStr), keys, 0);
                return expectValue.equalsIgnoreCase(resultValue);
            } else {
                return responseConfig.equalsIgnoreCase(responseStr);
            }
        } catch (Exception e) {
            log.error("根据出参配置[{}]解析响应结果[{}]产生异常[{}]。", responseConfig, responseStr, e.getMessage(), e);
            return false;
        }
    }


    /**
     * 递归获取请求成功的值
     * 配置是result.data.code=200这样的形式
     * @param resultJson
     * @param keys
     * @param index
     * @return
     */
    private String getResultValue(JSONObject resultJson, String[] keys, int index) {
        if (index >= keys.length) {
            log.error("根据[{}]无法获取返回值", Arrays.toString(keys));
            return "";
        }
        Object value = resultJson.get(keys[index]);
        if (value == null || StringUtils.isBlank(value.toString())) {
            return "";
        }
        if (value instanceof JSONObject) {
            resultJson = (JSONObject) value;
            return getResultValue(resultJson, keys, index + 1);
        } else {
            return value.toString();
        }
    }

    /**
     * 获取表达式中${}中的值
     *
     * @param content 变量表达式
     * @return 变量列表
     */
    private List<String> getVariableNames(String content) {
        Matcher matcher = VAR_PATTERN.matcher(content);
        List<String> variableList = new ArrayList<>();
        while (matcher.find()) {
            variableList.add(matcher.group(1));
        }
        return variableList;
    }
}

参数解析器

package com.example.spring_boot_study.spring.spell;


import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 变量解析器选择器
 */
public class VariableParseSelector {
 
    private static final Map<String, VariableParser> PARSER_MAP = new ConcurrentHashMap<>();

    public static void registerParser(String variableName, VariableParser variableParser) {
        PARSER_MAP.put(variableName, variableParser);
    }
 
    public static VariableParser selectParser(String variableName) {
        return PARSER_MAP.get(variableName);
    }
}
 
package com.example.spring_boot_study.spring.spell;


import com.alibaba.fastjson.JSONObject;

import java.util.Map;

/**
 * Description: 变量解析接口
 */
public interface VariableParser {

    /**
     * 变量配置解析
     *
     * @param variableName 变量名
     * @param msgJson      消息体(包含所有参数对应的参数值)
     * @return 变量
     */
    Object parseVariable(String variableName, JSONObject msgJson);
}
 
 
package com.example.spring_boot_study.spring.spell;

import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * Description:
 * 参数解析器
 */
@Component
public class OppoExposeParser implements VariableParser, InitializingBean {


    /**
     * 有些参数值是需要调具体的service去获取的，可以在这里实现
     * 也可以在封装msgJson的时候实现好。这里用到的是参数值封装好在msgJson的形式
     * @param variableName 变量名
     * @param msgJson      消息体
     * @return
     */
    @Override
    public Object parseVariable(String variableName,  JSONObject msgJson) {
        switch (variableName) {
            case "oppoPhoneIdName": {
                if (true) {
                    return "oppoPhoneIdName";
                }
                return "companyName";
            }
            case "oppoPhoneIdValue": {
                return msgJson.get("oppoPhoneIdValue");
            }
            case "oppoExposeTimestamp": {
                return msgJson.get("oppoExposeTimestamp");
            }
            case "oppoAdId": {
                return msgJson.get("oppoAdId");
            }
            case "oppoType": {
                return msgJson.get("oppoType");
            }
            case "requestBody": {
                return msgJson.get("requestBody");
            }
            default:
                return "";
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        VariableParseSelector.registerParser("oppoPhoneIdName", this);
        VariableParseSelector.registerParser("oppoPhoneIdValue", this);
        VariableParseSelector.registerParser("oppoExposeTimestamp", this);
        VariableParseSelector.registerParser("oppoAdId", this);
        VariableParseSelector.registerParser("oppoType", this);
        VariableParseSelector.registerParser("oppoType", this);
    }
}

工具类

package com.example.spring_boot_study.spring.spell;

import cn.hutool.crypto.digest.MD5;
import com.example.spring_boot_study.SpringEl.AesFunction;
import com.example.spring_boot_study.SpringEl.DateFunction;
import com.example.spring_boot_study.SpringEl.HmacSha1Function;
import com.example.spring_boot_study.SpringEl.MathFunction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.SpelCompilerMode;
import org.springframework.expression.spel.SpelParserConfiguration;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.SimpleEvaluationContext;

import java.util.HashMap;
import java.util.Map;

/**
 * Description: SpringEl获取静态Method
 */
@Slf4j
public class SpringElUtil {

    /**
     * IMMEDIATE - 在即时模式下，尽快编译表达式。这通常是在第一次解释评估之后。
     * 如果编译的表达式失败（通常是由于类型改变，如上所述），则表达式评估的调用者将收到异常。
     */
    public static final SpelParserConfiguration CONFIG = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
            SpringElUtil.class.getClassLoader());

    /**
     * 对公共method的进行缓存 防止每次都getDeclaredMethod
     * 所有方法必须都是静态方法
     * 这里使用自定义函数，简化方法的调用
     * 只演示ceil方法，aes方法等其他所需方法可自行实现
     */
    private static final Map<String, Object> METHOD_CACHE = new HashMap<String, Object>() {{
        try {
            put("ceil", Math.class.getDeclaredMethod("ceil", double.class));
//            put("hmac", HmacSha1Function.class.getDeclaredMethod("encrypt", String.class, String.class));
            put("aes", AesFunction.class.getDeclaredMethod("strEncodeBase64", String.class, String.class));
//            put("currentTimeMillis", DateFunction.class.getDeclaredMethod("currentTimeMillis"));
//            put("currentTimeSeconds", DateFunction.class.getDeclaredMethod("currentTimeSeconds"));
//            put("currentStringDate", DateFunction.class.getDeclaredMethod("currentStringDate"));
        } catch (NoSuchMethodException e) {
            log.error("SpringEl获取方法失败", e);
        }
    }};

    public static EvaluationContext createContext() throws NoSuchMethodException {
        //这里因为安全 设置了只读模式，如需其他模式可以自行更改
        //  StandardEvaluationContext有注入风险，所以使用SimpleEvaluationContext
        //SimpleEvaluationContext是 StandardEvaluationContext子集，功能没那么多
        EvaluationContext ctx = SimpleEvaluationContext.forReadOnlyDataBinding().build();
        METHOD_CACHE.forEach(ctx::setVariable);
        return ctx;
    }

    public static void main(String[] args) throws Exception{
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = SpringElUtil.createContext();
        Object value = parser.parseExpression("#ceil(1.345)").getValue(context);
        System.out.println(value);
    }



}
package com.example.spring_boot_study.spring.spell;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.Key;
import java.util.Base64;

/**
 * AES加密
 */
public class AesFunction {
 
    private static final String AES_ECB_PKCS5PADDING = "AES/ECB/PKCS5Padding";
 
    public static String strEncodeBase64(String data, String base64Key) {
        final Key dataKey = new SecretKeySpec(Base64.getDecoder().decode(base64Key), "AES");
        try {
            Cipher cipher = Cipher.getInstance(AES_ECB_PKCS5PADDING);
            cipher.init(Cipher.ENCRYPT_MODE, dataKey);
            byte[] encryptData = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encryptData).replaceAll("\r", "").replaceAll("\n", "");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    public static void main(String[] args) {
        System.out.println(AesFunction.strEncodeBase64("123", "XGAXicVG5GMBsx5bueOe4w=="));
    }


}

入参：

package com.example.spring_boot_study.spring.spell;

import lombok.Data;

@Data
public class RequestDemo {

    /**
     * 请求URL,如果需要带动态参数（非写死的参数），以${参数名形式}
     */
    private String url;

    /**
     * 请求类型 1、Get 2、Post
     */
    private Integer requestType;


    /**
     * 请求头配置
     */
    private String requestHeader;


    /**
     * 请求配置
     */
    private String requestConfig;

    /**
     * 响应配置
     */
    private String responseConfig;
}

模拟入参：

 RequestDemo requestDemo = new RequestDemo();
        requestDemo.setRequestConfig("{\n" +
                "\t\"timestamp \": \"${oppoExposeTimestamp}\",\n" +
                "\t\"adId\": \"${oppoAdId}\",\n" +
                "\t\"dataType\": 2,\n" +
                "\t\"ascribeType\": 1,\n" +
                "\t\"channel\": 1,\n" +
                "\t\"type\": \"${oppoType}\",\n" +
                "\t\"pkg\": \"com.credit\",\n" +
                "\t\"${oppoPhoneIdName}\": \"#aes(${oppoPhoneIdValue},'XGAXicVG5GMBsx5bueOe4w==')\"\n" +
                "}");

        // 注意我这里构建了一个md5(String str)的方法，而我在SpringElUtil里并没有自定义md5(String str)
        // 方法，所以肯定会报错，需要啥方法就要预先在SpringElUtil定义
        requestDemo.setRequestHeader("{\n" +
                "\t\"Content-Type\": \"application/json;charset=UTF-8\",\n" +
                "\t\"signature\": \"#md5(${requestBody}+${oppoExposeTimestamp}+'e0u6fnlag06lc3pl')\",\n" +
                "\t\"timestamp\": \"${oppoExposeTimestamp}\"\n" +
                "}");

        // 封装参数对应的值
        JSONObject msgJson = new JSONObject();
        msgJson.put("custNo", "123");
        msgJson.put("oppoPhoneIdName", "123");
        msgJson.put("oppoPhoneIdValue", "123");
        msgJson.put("oppoExposeTimestamp", new Date());
        msgJson.put("oppoAdId", "123");
        msgJson.put("oppoType", "123");

        // 可以自己写一个Controller实现具体的接口，我这里随便写的
        // 下面的返回也是一样，调试时，屏蔽http调用，构造返回参数即可
        // 调用真实的url,可根据具体要求设置responseConfig
        requestDemo.setUrl("/test");
        requestDemo.setResponseConfig("result.data.code=200");

码上得天下
关注
专栏目录
Nuxt - 解决 @nuxt/axios 自带请求无法针对特殊接口，设置 “个性自定义“ 请求地址 url / 请求头 header 等（常见于项目文件上传下载、调用几个第三方接口）详细示例教程！
王佳斌
04-20 2705
nuxt项目如何给单独某个接口增加额外的headers，nuxt 怎么单独请求一个第三方接口,非baseurl的接口地址，nuxt 一个项目有多个url请求地址怎么办，nuxt2 上传文件接口需要设置单独的headers请求头怎么办，nuxt.js 请求配置baseurl只写了一个，但项目需要调用其他的接口地址如何解决，nuxt如何解决@nuxt/axios无法单独给一个接口设置请求头/响应头参数，nuxt遇到了无法给某个后端接口设置独立的参数问题，nuxt 调用文件下载接口怎么只给这个接口设置一些额外的参
【python005】python批量、动态调参请求接口（已更新）
kngines
05-24 1179
1.熟悉、梳理、总结项目研发实战中的`Python开发`日常使用中的问题。随着版本更新，做了一些变动，如商业化限制，取消一些语法等。 2.欢迎点赞、关注、批评、指正，互三走起来，小手动起来！
JavaURL加请求头怎么加
weixin_37035580的博客
08-05 49
使用JavaURL添加请求头的方案 在Web开发中，API的请求常常需要携带特定的请求头（Header）。在Java中，我们可以使用HttpURLConnection类来实现对URL的请求，并且很方便地为请求添加自定义的请求头。本文将通过一个具体的示例，详细介绍Java中如何使用URL添加请求头。 问题背景 假设我们需要向...
Python3中urllib库的两种添加请求头的方式
两个月亮
10-22 6751
【代码】Python3中urllib库的两种添加请求头的方式。
HttpUrlConnection使用简介
lck_csdn的博客
07-15 3952
HttpUrlConnection创建http连接
url的详解，常用请求方法，请求头常见参数，常见响应状态码
weixin_44737646的博客
12-05 4796
URL的组成和说明 URL是uniform Resource locator的简写，中文意思是统一资源定位符 scheme： 代表的是访问的协议， 一般为http或者https以及ftp等 host：主机名，域名，比如：www.baidu.com port：端口号，当你访问一个网站时，浏览器默认使用80端口 path：查找路径，比如：https://mp.csdn.net/mdeditor/1...
ReqTool:请求调试工具，格式化入参和出参。。
06-28
这款工具能够方便地格式化输入参数（入参）和输出参数（出参），使得请求和响应的数据更加清晰易读，提高开发效率。 在Java开发环境中，调试HTTP请求通常涉及到使用如Postman这样的第三方工具，或者手动构造HTTP...
postman设置环境变量，上一个接口的出参作为下一个接口的入参
HCy996的博客
08-16 933
在用postman测试接口的时候，常用的url都可以直接设置成环境变量，分析一下，博主顺便做个记录 一、把url配置成环境变量使用 1：点击设置 2：点击添加 3：编辑变量内容 4：接口引用，使用 {{引用的变量}} 这里是{{104url}} 二、上一个接口的出参作为下一个接口的入参 1：以上面的登录返回的access_token为例，在text里输入以下内容 2:验证变量是否获取成功，查看设置的变量名称是否有值 3：下一个接口引用 ...
浅谈vue中get请求解决传输数据是数组格式的问题
10-15
当使用GET请求时，参数通常会被编码并附加到URL上。然而，如果这些参数是数组形式，它们需要特殊处理，以免导致服务器解析错误。本文将探讨如何在Vue中使用GET请求处理数组格式的数据。 首先，让我们了解`qs`库。`...
url请求头信息
分享互联网的有趣知识~
10-04 456
url请求头信息，通过请求分析当前请求携带了哪些信息，例如token、cookie、身份验证、语言类型、内容编码、协议、端口等等
已解决urllib模块设置代理ip
努力让自己发光，对的人才能迎着光而来
10-01 9739
已解决urllib模块设置代理ip
img使用src动态请求图片，同时需要设置请求头header的问题
热门推荐
在车上在路上的博客
03-22 3万+
目前做的项目里面有个二维码是动态加载出来的，最初使用vue双向绑定src实现了src能自动请求图片。 html <img :src="src"> js data:{ src:'' }, mounted: function(){ this.src = 'xxxxx/xxxxx/xxx?phoneNum='+phoneNum+'&width=200&height=20...
02、HTTP基本原理之URL、请求和响应
weixin_44749822的博客
04-17 2727
文章目录前言一、URI和URL二、请求(Request)1、请求方法（Request Method）*a、常见的请求方法：GET和 POST**b、GET和 POST请求方法有如下区别：**c、请求方法和描述*2、请求的网址（Request URL）3、请求头（Request Header）4、请求体（Request Body）5、Content-Type和POST提交数据方式的关系三、响应（Response）1、响应状态码（Response Status Code）2、响应头（Response Head.
url的请求头
More reading and learning to become excellent
11-03 653
在下面的NSURLSessionDataTask的一个实例中可以获取到这个task的所有请求头
HTTP报文详解
lvwenwen
06-28 6047
文章链接：http://www.iteye.com/topic/1124408 引用 学习Web开发不好好学习HTTP报文，将会“打拳不练功，到老一场空”，你花在犯迷糊上的时间比你沉下心来学习HTTP的时间肯定会多很多。 HTTP请求报文解剖 HTTP请求报文由3部分组成（请求行+请求头+请求体）：  下面是一个实际的请求报文：  ①是请求方法，GET和POST是最常见的HTTP方法...
HttpURLConnection如何添加请求头？
weixin_33796205的博客
12-09 7581
1.conn.setRequestProPerty(name,value)，两个参数都是字符串。。。。 2.用httpURLConnection的setRequestProPerty(name,value)方法，就能向header里添加信息。 如：设置content-type httpURLConnection.setRequestProperty("token", "10051:abc...
新springboot项目@requestbody接收不到入参
最新发布
09-12
5. **前端错误**：确保前端发送的请求是正确的，比如URL、POST数据以及请求头信息都正确无误。 6. **IDE问题**：有时候IDE的自动补全或者格式化操作可能导致请求体丢失，尝试清理一下请求的输入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值