http请求

最新推荐文章于 2022-12-09 15:09:28 发布
最新推荐文章于 2022-12-09 15:09:28 发布
阅读量177 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengyingsuixu/article/details/86596923
版权 
HttpThreeConn
package com.lv.http;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.http.HttpStatus;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Created by LocalUser on 2018/3/27.
 */
public class HttpThreeConn {

    public static byte[] toByteArray(InputStream is, byte[] byteArray) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int n;
        while(-1 != (n = is.read(byteArray))) {
            bos.write(byteArray, 0, n);
        }

        return bos.toByteArray();
    }
    /**
     * 根据入参实体类动态生成入参参数
     *
     * @param object
     * @return
     * @throws com.fasterxml.jackson.core.JsonProcessingException
     */
    public static String fromObjectToStr(Object object) throws JsonProcessingException {
        ObjectMapper writeMapper = new ObjectMapper();
        return writeMapper.writeValueAsString(object);
    }

    /**
     * post请求
     *
     * @param serverBeanId
     * @param entity
     * @return
     * @throws Exception
     */
    public static String doPost(String serverUrl, String serverBeanId,Object entity) throws Exception {
        StringBuilder url = new StringBuilder();
        url.append(serverUrl).append(serverBeanId);
        String responseBody = null;
        PostMethod postMethod = new PostMethod(url.toString());
        String env = fromObjectToStr(entity);
        postMethod.setRequestBody(env);
        int statusCode = -1;
        try {
            HttpClient httpClient = new HttpClient();
            httpClient.getParams().setParameter(
                    HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");
            statusCode = httpClient.executeMethod(postMethod);
            if (HttpStatus.SC_OK == statusCode) {
                InputStream resultIS = null;
                try {
                    resultIS = postMethod.getResponseBodyAsStream();
                    responseBody = new String(toByteArray(resultIS, new byte[8192]),"UTF-8");

                } catch (IOException e) {

                } finally {
                    if (null != postMethod) {
                        postMethod.releaseConnection();
                    }
                }
            }

        } catch (Exception e) {

        }
        return responseBody;
    }


    public static String doGet(String serverUrl,String serverBeanId){
        StringBuilder url = new StringBuilder();
        // 获取环境变量值
        url.append(serverUrl).append(serverBeanId);
        String responseBody = null;
        GetMethod getMethod = new GetMethod(url.toString());
        int statusCode = -1;

        try{
            HttpClient httpClient = new HttpClient();
            statusCode = httpClient.executeMethod(getMethod);

            if(HttpStatus.SC_OK == statusCode){

                InputStream resultIS = getMethod.getResponseBodyAsStream();
                responseBody = new String(toByteArray(resultIS, new byte[8192]),"UTF-8");
            }
        }catch (Exception e){

        }finally {
            getMethod.releaseConnection();
        }
        return responseBody;
    }
}

HttpPool

package com.cmb.dw.rtl.pbutils.http;

import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;

import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;

/**
 * Created by lvyanghui on 2018/9/20.
 */
public class HttpPool {

    private static PoolingHttpClientConnectionManager connManager = null;

    static{

        ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
        LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().
                register("http", plainsf).register("https", sslsf).build();
        connManager = new PoolingHttpClientConnectionManager(registry);

    }

    private static PoolingHttpClientConnectionManager getInstance(){

        /**
         * socket配置（默认配置 和 某个host的配置）
         */
        SocketConfig socketConfig = SocketConfig.custom()
                .setTcpNoDelay(true)     //是否立即发送数据，设置为true会关闭Socket缓冲，默认为false
                .setSoReuseAddress(true) //是否可以在一个进程关闭Socket后，即使它还没有释放端口，其它进程还可以立即重用端口
                .setSoTimeout(500)       //接收数据的等待超时时间，单位ms
                .setSoLinger(60)         //关闭Socket时，要么发送完所有数据，要么等待60s后，就关闭连接，此时socket.close()是阻塞的
                .setSoKeepAlive(true)    //开启监视TCP连接是否有效
                .build();

        connManager.setMaxTotal(1000);
        connManager.setDefaultMaxPerRoute(200);
        connManager.setDefaultSocketConfig(socketConfig);
        return connManager;
    }

    public static RequestConfig getRequestConfig() {

        // 配置请求的超时设置
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(500)    //从池中获取连接超时时间
                .setConnectTimeout(2 * 1000)         //连接超时时间
                .setSocketTimeout(2 * 1000)          //读超时时间（等待数据超时时间）
                //.setStaleConnectionCheckEnabled(true)//检查是否为陈旧的连接，默认为true，类似testOnBorrow
                .build();
        return requestConfig;
    }

    private static HttpRequestRetryHandler getRetryHandler(){
        // 请求重试处理
        HttpRequestRetryHandler retryHandler = new HttpRequestRetryHandler() {
            public boolean retryRequest(IOException exception,
                                        int executionCount, HttpContext context) {
                if (executionCount >= 2) {// 假设已经重试了2次，就放弃
                    return false;
                }
                if (exception instanceof NoHttpResponseException) {// 假设server丢掉了连接。那么就重试
                    return true;
                }
                if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
                    return false;
                }
                if (exception instanceof InterruptedIOException) {// 超时
                    return false;
                }
                if (exception instanceof UnknownHostException) {// 目标server不可达
                    return false;
                }
                if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
                    return false;
                }
                if (exception instanceof SSLException) {// SSL握手异常
                    return false;
                }

                HttpClientContext clientContext = HttpClientContext.adapt(context);
                HttpRequest request = clientContext.getRequest();
                // 假设请求是幂等的，就再次尝试
                if (!(request instanceof HttpEntityEnclosingRequest)) {
                    return true;
                }
                return false;
            }
        };

        return retryHandler;
    }

    public static CloseableHttpClient getHttpClient(){

        connManager = getInstance();
        RequestConfig requestConfig = getRequestConfig();
        HttpRequestRetryHandler retryHandler = getRetryHandler();

        CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).setDefaultRequestConfig(requestConfig).setRetryHandler(retryHandler).build();
        return client;
    }


}

HttpRequestUtil

package com.cmb.dw.rtl.pbutils.http;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

import java.io.IOException;

/**
 * Created by lvyanghui on 2018/9/20.
 */
public class HttpRequestUtil {

    private static final Logger LOGGER = Logger.getLogger(HttpRequestUtil.class);

    private static final String UTF_8 = "utf-8";

    private static String getHttpUrl(String serverUrl,String serverBeanId) throws IOException{

        StringBuilder url = new StringBuilder("");
        url.append(serverUrl).append(serverBeanId);
        LOGGER.info("http请求url:" + url);

        if(url.length() == 0){
            throw new IOException("http请求url为空!");
        }
        return url.toString();
    }

    private static StringEntity getParams(Object obj)throws JsonProcessingException {

        ObjectMapper om = new ObjectMapper();
        String json = om.writeValueAsString(obj);
        StringEntity params = new StringEntity(json, UTF_8);
        return params;
    }

    private static void setProps(HttpPost httpPost,Object obj)throws JsonProcessingException{

        StringEntity params = getParams(obj);
        LOGGER.info("http请求参数:" + params);
        httpPost.setEntity(params);

    }

    private static String getResult(HttpRequestBase httpRequest)throws IOException{

        String result = null;
        CloseableHttpResponse response = null;
        try{
            CloseableHttpClient client = HttpPool.getHttpClient();
            response = client.execute(httpRequest);
            int statusCode = response.getStatusLine().getStatusCode();
            LOGGER.info("http请求响应code:" + statusCode);
            if(HttpStatus.SC_OK == statusCode){
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity, UTF_8);
                EntityUtils.consume(entity);
                LOGGER.info("http请求结果:" + result);
                return result;
            }else{
                throw new ClientProtocolException("调用http请求" + httpRequest.getURI() + "错误代码："+statusCode);
            }
        }catch (IOException ioe){
            throw new IOException(ioe.getMessage());
        }finally {
            if(null != response){
                response.close();
            }
        }

    }

    public static String doPost(String serverUrl,String serverBeanId, Object obj)throws IOException {

        String url = getHttpUrl(serverUrl,serverBeanId);

        HttpPost httpPost = new HttpPost(url);

        setProps(httpPost,obj);

        String result = getResult(httpPost);

        return result;

    }


    public static String doGet(String serverUrl,String serverBeanId)throws IOException {

        String url = getHttpUrl(serverUrl,serverBeanId);

        HttpGet httpGet = new HttpGet(url);

        String result = getResult(httpGet);

        return result;
    }


}

HttpRestUtil
package com.cmb.dw.rtl.pbutils.http;

import com.cmb.dw.rtl.commons.util.StringUtils;
import com.cmb.dw.rtl.pbutils.model.http.HttpInterfaceObj;
import com.cmb.dw.rtl.pbutils.model.http.HttpRequestCstCd;
import com.cmb.dw.rtl.pbutils.util.MapBeanUtil;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.apache.log4j.Logger;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Created by lvyanghui
 * 2018/9/20 10:28
 */
public class HttpRestUtil {


	public static HttpInterfaceObj httpInterfaceObjV1 = null;
    public static HttpInterfaceObj httpInterfaceObjV2 = null;
    public static HttpInterfaceObj httpInterfaceObjV3 = null;
    public static HttpInterfaceObj httpInterfaceObjV4 = null;

    private static final Logger LOGGER = Logger.getLogger(HttpRestUtil.class);

    static {
        httpInterfaceObjV1 = new HttpInterfaceObj(HttpRequestCstCd.CODE,HttpRequestCstCd.DATA,HttpRequestCstCd.ERRMSG,HttpRequestCstCd.F);
        httpInterfaceObjV2 = new HttpInterfaceObj(HttpRequestCstCd.SUCCESS,HttpRequestCstCd.RESULT,HttpRequestCstCd.MESSAGE,HttpRequestCstCd.FALSE);
        httpInterfaceObjV3 = new HttpInterfaceObj(HttpRequestCstCd.CODE,HttpRequestCstCd.DATA,HttpRequestCstCd.ERRMSG,HttpRequestCstCd.FAILURE_CODE);
        httpInterfaceObjV4 = new HttpInterfaceObj(HttpRequestCstCd.CODE,HttpRequestCstCd.RESULT,HttpRequestCstCd.ERRMSG,HttpRequestCstCd.FAILURE_CODE);
    }
    /**
     * 获取httpPost请求结果
     * @param url           http请求url
     * @param serviceId     http请求mvc service编号
     * @param params        请求参数
     * @return
     * @throws IOException
     */
    public static String getHttpPostResult(String url,String serviceId,Object params)throws IOException{

        String result = HttpRequestUtil.doPost(url,serviceId,params);
        LOGGER.info("post请求结果:" + result);
        return result;
    }

    /**
     * 获取httpGet请求结果
     * @param url           http请求url
     * @param serviceId     http请求mvc service编号
     * @return
     * @throws IOException
     */
    public static String getHttpGetResult(String url,String serviceId)throws IOException{

        String result = HttpRequestUtil.doGet(url,serviceId);
        LOGGER.info("get请求结果:" + result);
        return result;
    }

    /**
     *
     * @author wwj
     * @date 2018年9月29日 上午8:56:35
     * @method getResultDataCsv
     * @see:CSV接口回返值转换
     */
    public static Object getResultDataCsv(String result) throws Exception{
        ObjectMapper om = new ObjectMapper();
        Object resultData = null;
        if (!StringUtils.isEmpty(result)) {
            resultData = om.readValue(result, Object.class);
        }
        return resultData;
    }

    /**
     * 根据http返回结果获取结果数据
     * @param result            http结果
     * @param interfaceObj      接口对象
     * @return
     * @throws Exception
     */
    public static Object getResultData(String result, HttpInterfaceObj interfaceObj) throws Exception {

        Object resultData = null;

        if(null != result){
            ObjectMapper om = new ObjectMapper();
            Map<String,Object> resultMap = om.readValue(result,Map.class);

            if(!CollectionUtils.isEmpty(resultMap)){

                String code = String.valueOf(resultMap.get(interfaceObj.getCode()));
                if(interfaceObj.getErrCode().equals(code)){
                	throw new Exception(getErrMsg(resultMap.get(interfaceObj.getErrMsg())));
                }else{
                    resultData = resultMap.get(interfaceObj.getData());
                }
            }
        }

        return resultData;
    }

    /**
     * 根据结果数据返回对象
     * @param resultData    结果数据
     * @param clazz         对象类型
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> T getRestResultBean(Object resultData, Class<T> clazz) throws InstantiationException, IllegalAccessException{

        T bean = null;

        if(null != resultData){
            Map<String,Object> resultMapData = (Map<String,Object>)resultData;
            if(!CollectionUtils.isEmpty(resultMapData)){
                bean = MapBeanUtil.mapToBean(resultMapData, clazz);
            }
        }

        return bean;

    }

    /**
     * 根据结果数据返回对象集合
     * @param resultData        结果数据
     * @param clazz             对象类型
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    public static <T> List<T> getRestResultList(Object resultData, Class<T> clazz)throws InstantiationException, IllegalAccessException{

        List<T> list = null;
        if(null != resultData){
            List<Map<String,Object>> resultMapList = (List<Map<String,Object>>)resultData;
            if(!CollectionUtils.isEmpty(resultMapList)){
                list = MapBeanUtil.mapsToObjects(resultMapList, clazz);
            }
        }
        return list;
    }
    
    /**
     * 
     * @author wwj
     * @date 2018年10月17日 下午2:58:17
     * @method getErrMsg
     * @see :错误信息转换
     */
	private static String getErrMsg(Object errObj) {
		String errMsg = "";
		if (errObj instanceof String) {
			errMsg = (String) errObj;
		}else if(errObj instanceof List){
			List<String> errMsgList = (List<String>)errObj;
			if(!CollectionUtils.isEmpty(errMsgList)){
				for (String err : errMsgList) {
					errMsg += err;
				}
			}
		}
		return errMsg;
	}

}

 

fengyingsuixu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-http连接池的使用
撸码人
08-17 4772
最近项目中开发有很多外部http调用，但是我方的接口相应有时效性要求，所以就需要针对项目使用到的http调用进行连接池改造，原先没做也是时效性要求不是很严格，但是现在需要了，就需要整体调整，这也是对原先开发不负责的后果吧。 废话不多说，项目中使用到的http调用方式，这个方式有三种，为啥有三种也不多说了，谁让建项初期没做严格要求，导致大家都是使用自己习惯的方式去完成的设计。 目前有三种：httpclient、resttemplate、feign，接下来针对一样一样的记录了。 1、httpclient
HttpClient4.x 工具类与多线程测试用例
ycb1689的专栏
05-31 1180
不多说了直接上代码，代码经过线上测试过 import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InterruptedIOException; import java.net.Unknow...
HttpClien高并发请求连接池 - PoolingHttpClientConnectionManager
soman的博客
03-15 3万+
        连接池技术作为创建和管理连接的缓冲池技术，目前已广泛用于诸如数据库连接等长连接的维护和管理中，能够有效减少系统的响应时间，节省服务器资源开销。其优势主要有两个：其一是减少创建连接的资源开销，其二是资源的访问控制。连接池管理的对象是长连接，对于HTTP连接是否适用，我们需要首先回顾一下长连接和短连接。       所谓长连接是指客户端与服务器端一旦建立连接以后，可以进行多次数据传输而...
Java HttpClient中的三种超时设置区别
z69183787的专栏
09-20 2万+
最近项目中在使用HttpClient有三个超时(connectionRequestTimeout,connectTimeout,socketTimeout)时间理解得不是很透彻，API文档不是很理解，专门写Demo理解了一下。 API的描述如下： /** * Returns the timeout in milliseconds used when requesting a co
JMeter测试问题：java.net.SocketTimeoutException: connect timed out，Read timed out
测试方圆
07-05 7万+
最近使用JMeter执行分布式性能测试，对HTTP服务器（Apache2）进行压测。在线程组的线程数增加到一定值时，有概率产生connect timed out和Read timed out错误。关于这两个错误，前者较好解释，后一个错误产生原因尚未有定论。 先交代下测试计划的设置： JMeter测试计划线程组设置：Ramp-UP Period为5秒。勾选【delaythre...
HTTP请求分析
骑个小蜗牛的博客
09-08 6829
1. application/x-www-form-urlencoded 这应该是最常见的 POST 提交数据的方式了。浏览器的原生 form 表单，如果不设置 enctype 属性，那么最终就会以 application/x-www-form-urlencoded 方式提交数据。 请求类似于下面这样（无关的请求头在本文中都省略掉了）： POST http://www.example.com HTTP/1.1 Content-Type: application/x-www-form-urlencoded;c
C#——HTTP请求
weixin_50478033的博客
12-09 1万+
HTTP请求
HTTP请求流程
GoodLinGL的博客
05-14 5496
HTTP协议是建立在TCP连接基础之上的。HTTP 是一种允许浏览器向服务器获取资源的协议，是 Web 的基础，通常由浏览器发起请求，用来获取不同类型的文件， 例如 HTML 文件、CSS 文件、JavaScript 文件、图片、视频等。此外，HTTP 也是浏览器使用最广的协议。 浏览器端发起 HTTP 请求流程 浏览器输入网址：http://time.geekbang.org/index.html，之后会完成什么步骤呢？ 1、构建请求 首先，浏览器构建请求行信息，构建好后，浏览器准备发起网络请求。 GET
HTTP请求的完全过程
热门推荐
ailunlee的博客
05-27 15万+
HTTP请求的完全过程 1.1 浏览器根据域名解析IP地址 浏览器根据访问的域名找到其IP地址。DNS查找过程如下： 浏览器缓存：首先搜索浏览器自身的DNS缓存（缓存的时间比较短，大概只有1分钟，且只能容纳1000条缓存），看自身的缓存中是否是有域名对应的条目，而且没有过期，如果有且没有过期则解析到此结束。 系统缓存：如果浏览器自身的缓存里面没有找到对应的条目，那么浏览器会...
groovy http请求
11-26
在Groovy中发送HTTP请求是开发者经常需要进行的操作，尤其是在进行API测试或者集成第三方服务时。下面我们将深入探讨如何在Groovy中执行HTTP请求，并分享一些实用的工具和技巧。 1. **HTTP请求方法**： - GET：...
通过Java发送http请求
01-21
通常的http请求都是由用户点击某个连接或者按钮来发起的，但是在一些后台的Java程序中需要发送一些get或这post请求，因为不涉及前台页面，该怎么办呢？ 　下面为大家提供一个Java发送http请求的工具类 HttpRequest....
VB发送HTTP请求
09-08
在VB（Visual Basic）编程环境中，发送HTTP请求是一项常见的任务，尤其在开发Web应用程序或集成API接口时。本文将深入探讨如何使用VB实现这一功能，同时也会涉及网络中的一些基本制式转换。 首先，让我们理解HTTP...
HTTP 请求方法
01-08
HTTP 请求方法 根据 HTTP 标准，HTTP 请求可以使用多种请求方法。 HTTP1.0 定义了三种请求方法： GET, POST 和 HEAD方法。 HTTP1.1 新增了六种请求方法：OPTIONS、PUT、PATCH、DELETE、TRACE 和 CONNECT 方法。 ...
ESP8266之HTTP请求
01-06
ESP8266之HTTP请求前言GET请求POST请求 前言 HTTP需要引用两个头文件：ESP8266Client.h，ESP8266HTTPClient.h。 ESP8266根据网上的API使用HTTP请求来获取自己想要的信息，例如天气、阿里云的人工智能。 GET请求 定义...
HttpClient 4.3连接池参数配置及源码解读
Trust_FreeDom的专栏
01-25 1313
目前所在公司使用HttpClient 4.3.3版本发送Rest请求，调用接口。最近出现了调用查询接口服务慢的生产问题，在排查整个调用链可能存在的问题时（从客户端发起Http请求->ESB->服务端处理请求，查询数据并返回），发现原本的HttpClient连接池中的一些参数配置可能存在问题，如defaultMaxPerRoute、一些timeout时间的设置等，虽不能确定是由...
mybatis自动生成xml等文件
fengyingsuixu的博客
01-23 1637
  GenerateParamsUtil类 import java.io.*; import java.sql.*; import java.text.SimpleDateFormat; import java.util.*; import java.util.Date; /** * cmbxb 55.12.221.63/55.12.205.225 3306 app_usr/App_u...
spring手写源码一
fengyingsuixu的博客
01-16 494
分为三个包 aop包、bean包、samples包 aop包含advice、advisor、pointcut和各个类 advice包 Advice类 package com.lv.spring.aop.advice; /** * Created by lvyanghui * 2018/12/25 14:38 */ public interface Advice { } Af...
netty3.10.5尝试
fengyingsuixu的博客
01-23 456
ClientHandler package com.lv.netty; import org.jboss.netty.channel.*; /** * Created by LocalUser on 2018/1/24. */ public class ClientHandler extends SimpleChannelHandler { @Override publ...
redis使用
fengyingsuixu的博客
01-23 246
JedisUtil package com.lv.redis; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; /** * Created by lvyanghui * 2018/6/14 16:40 ...
jmeter http请求
最新发布
09-13
对于 JMeter 的 HTTP 请求，您可以使用 JMeter 进行压力测试和性能测试，模拟多个并发用户发送 HTTP 请求到目标服务器，并收集响应结果进行分析。 在 JMeter 中，您可以按照以下步骤创建和配置 HTTP 请求： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值