精华内容
下载资源
问答
我要提问
  • Java请求https接口
    千次阅读
    2020-06-13 14:44:09 
    package test;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;

/**
 * HTTP请求
 */
public class HTTPUtils {
    private static final int TIMEOUT = 45000;
    public static final String ENCODING = "UTF-8";

    /**
     * 创建请求连接
     * url:地址
     * method:方法
     * headerParameters:请求头
     * body:请求内容
     */
    private static HttpURLConnection createConnection(String url,
            String method, Map<String, String> headerParameters, String body)
            throws Exception {
        URL Url = new URL(url);
        trustAllHttpsCertificates();
        HttpURLConnection httpConnection = (HttpURLConnection) Url
                .openConnection();
        // 设置请求时间
        httpConnection.setConnectTimeout(TIMEOUT);
        // 设置 header
        if (headerParameters != null) {
            Iterator<String> iteratorHeader = headerParameters.keySet()
                    .iterator();
            while (iteratorHeader.hasNext()) {
                String key = iteratorHeader.next();
                httpConnection.setRequestProperty(key,
                        headerParameters.get(key));
            }
        }
        httpConnection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded;charset=" + ENCODING);
        // 设置请求方法
        httpConnection.setRequestMethod(method);
        httpConnection.setDoOutput(true);
        httpConnection.setDoInput(true);
        // 写query数据流
        if (!(body == null || body.trim().equals(""))) {
            OutputStream writer = httpConnection.getOutputStream();
            try {
                writer.write(body.getBytes(ENCODING));
            } finally {
                if (writer != null) {
                    writer.flush();
                    writer.close();
                }
            }
        }

        // 请求结果
        int responseCode = httpConnection.getResponseCode();
        if (responseCode != 200) {
            throw new Exception(responseCode
                    + ":"
                    + inputStream2String(httpConnection.getErrorStream(),
                            ENCODING));
        }
        return httpConnection;
    }

    /**
     * POST请求
     * address:请求地址
     * headerParameters:请求头
     * body:请求内容
     */
    public static String post(String address,
            Map<String, String> headerParameters, String body) throws Exception {

        return proxyHttpRequest(address, "POST", null,
                getRequestBody(headerParameters));
    }

    /**
     * GET请求
     * address:请求地址
     * headerParameters:请求头
     * body:请求内容
     */
    public static String get(String address,
            Map<String, String> headerParameters, String body) throws Exception {

        return proxyHttpRequest(address + "?"
                + getRequestBody(headerParameters), "GET", null, null);
    }

    /**
     * 读取网络文件
     * address:地址
     * headerParameters:请求头
     * file:文件
     */
    public static String getFile(String address,
            Map<String, String> headerParameters, File file) throws Exception {
        String result = "fail";
        HttpURLConnection httpConnection = null;
        try {
            httpConnection = createConnection(address, "POST", null,
                    getRequestBody(headerParameters));
            result = readInputStream(httpConnection.getInputStream(), file);
        } catch (Exception e) {
            throw e;
        } finally {
            if (httpConnection != null) {
                httpConnection.disconnect();
            }
        }
        return result;
    }
    
    public static byte[] getFileByte(String address,
            Map<String, String> headerParameters) throws Exception {
        byte[] result = null;
        HttpURLConnection httpConnection = null;
        try {
            httpConnection = createConnection(address, "POST", null,
                    getRequestBody(headerParameters));
            result = readInputStreamToByte(httpConnection.getInputStream());
        } catch (Exception e) {
            throw e;
        } finally {
            if (httpConnection != null) {
                httpConnection.disconnect();
            }
        }
        return result;
    }

    public static String readInputStream(InputStream in, File file)
            throws Exception {
        FileOutputStream out = null;
        ByteArrayOutputStream output = null;
        try {
            output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
            out = new FileOutputStream(file);
            out.write(output.toByteArray());
        } catch (Exception e) {
            throw e;
        } finally {
            if (output != null) {
                output.close();
            }
            if (out != null) {
                out.close();
            }
        }
        return "success";
    }
    
    public static byte[] readInputStreamToByte(InputStream in) throws Exception {
        FileOutputStream out = null;
        ByteArrayOutputStream output = null;
        byte[] byteFile = null;
        try {
            output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
                output.write(buffer, 0, len);
            }
            byteFile = output.toByteArray();
        } catch (Exception e) {
            throw e;
        } finally {
            if (output != null) {
                output.close();
            }
            if (out != null) {
                out.close();
            }
        }

        return byteFile;
    }

    public static String proxyHttpRequest(String address, String method,
            Map<String, String> headerParameters, String body) throws Exception {
        String result = null;
        HttpURLConnection httpConnection = null;
        try {
            httpConnection = createConnection(address, method, headerParameters, body);
            String encoding = "UTF-8";
            if (httpConnection.getContentType() != null
                    && httpConnection.getContentType().indexOf("charset=") >= 0) {
                encoding = httpConnection.getContentType().substring(httpConnection.getContentType().indexOf("charset=") + 8);
            }
            result = inputStream2String(httpConnection.getInputStream(), encoding);
        } catch (Exception e) {
            throw e;
        } finally {
            if (httpConnection != null) {
                httpConnection.disconnect();
            }
        }
        return result;
    }

    /**
     * 将参数化为 body
     * @param params
     * @return
     */
    public static String getRequestBody(Map<String, String> params) {
        return getRequestBody(params, true);
    }

    /**
     * 将参数化为 body
     * @param params
     * @return
     */
    public static String getRequestBody(Map<String, String> params,
            boolean urlEncode) {
        StringBuilder body = new StringBuilder();
        Iterator<String> iteratorHeader = params.keySet().iterator();
        while (iteratorHeader.hasNext()) {
            String key = iteratorHeader.next();
            String value = params.get(key);
            if (urlEncode) {
                try {
                    body.append(key + "=" + URLEncoder.encode(value, ENCODING)
                            + "&");
                } catch (UnsupportedEncodingException e) {
                	
                }
            } else {
                body.append(key + "=" + value + "&");
            }
        }
        if (body.length() == 0) {
            return "";
        }
        return body.substring(0, body.length() - 1);
    }

    private static String inputStream2String(InputStream input, String encoding)
            throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(input,
                encoding));
        StringBuilder result = new StringBuilder();
        String temp = null;
        while ((temp = reader.readLine()) != null) {
            result.append(temp);
        }

        return result.toString();

    }

    private static void trustAllHttpsCertificates() throws Exception {
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
            public boolean verify(String str, SSLSession session) {
                return true;
            }
        });
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
        javax.net.ssl.TrustManager tm = new miTM();
        trustAllCerts[0] = tm;
        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext
                .getInstance("SSL");
        sc.init(null, trustAllCerts, null);
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc
                .getSocketFactory());
    }


    //设置 https 请求证书
    static class miTM implements javax.net.ssl.TrustManager,javax.net.ssl.X509TrustManager {
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }
        
        public boolean isServerTrusted(
                java.security.cert.X509Certificate[] certs) {
            return true;
        }
        
        public boolean isClientTrusted(
                java.security.cert.X509Certificate[] certs) {
            return true;
        }
        
        public void checkServerTrusted(
                java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }
        
        public void checkClientTrusted(
                java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }
    }

    public static void main(String[] args) {
    	try {
            //请求地址
            String address = "https://api.bknks.com/getUser";
            //请求参数
            Map<String, String> params = new HashMap<String, String>();
            params.put("tel", "13299999999");
            // 调用 post 请求
            String res = get(address, params, null);
            System.out.println(res.replaceAll("[\\(\\)]", ""));//打印返回参数
        } catch (Exception e) {
            // TODO 异常
            e.printStackTrace();
        }
    }

}
    https
    更多相关内容

  • JMeter进行性能测试实例Java请求+参数化

     热门讨论 2013-12-13 17:55:34
    JMeter进行性能测试实例Java请求+参数化
    收起

  • Jmeter发送java请求

     千次阅读 2022-04-03 23:07:05
    jmeter发送java请求，主要实现jmeter发送java 写的功能，得到返回值 二、实现 1、java代码需要添加jmeter 的一些包 如果是jmeter比较高的版本，需要再添加截图下的包 2.代码需要实现jmeter的类 3.把主要...

    一、概述

    jmeter发送java请求，主要实现jmeter发送java 写的功能，得到返回值

    二、实现

    1、java代码需要添加jmeter 的一些包

    如果是jmeter比较高的版本，需要再添加截图下的包

    2.代码需要实现jmeter的类

     

    3.把主要容重写再runtest方法上

    如果需要返回值，需要在sampleResult setResponseData赋值并return

     

     

    setup方法主要是写入初始化的内容，比如以下内容，把数据库初始的连接信息写在初始化方法 

    teardowntest 方法主要是执行需要最后执行的方法，比如以下内容主要是执行最后的关闭数据连接

     

    java 代码打包

     

     

     

     

     

    jmeter 新建java 请求

     

     

    java代码入参参数化 

    jmeter设置

     

     java代码写法

     

     

     

    收起
    展开全文
    测试工具

  • java请求post接口方法

     千次阅读 2022-03-03 15:29:53
    pom.xml中添加以下jar <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.59<...commons-httpclient<.

    pom.xml中添加以下jar

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.59</version>
</dependency>

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

    代码如下

    package com.example.demo;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.PostMethod;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;

@SpringBootTest
class DemoApplicationTests {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    /*@Test
    public void post() throws Exception{
        try {
            String uri = "http://112.30.157.105:8082/IOTWebService/rest/oauth2/token";
            PostMethod postMethod = new PostMethod(uri);
            postMethod.setRequestHeader("content-type", MediaType.APPLICATION_FORM_URLENCODED_VALUE);
            NameValuePair[] nameValuePairs = {
                    new NameValuePair("client_id", "60dcb643-657b-49a8-b820-2c75b236edba"),
                    new NameValuePair("client_secret", "752d37c6-33ea-4a27-b856-05a9c67c4572"),
                    new NameValuePair("grant_type", "client_credentials")
            };
            postMethod.setRequestBody(nameValuePairs);
            HttpClient httpClient = new HttpClient();
            int responseCode = httpClient.executeMethod(postMethod);
            System.out.println("响应码：" + responseCode);
            String responseBodyAsString = postMethod.getResponseBodyAsString();
            System.out.println(responseBodyAsString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/

    @Test
    public void post() throws Exception{
        try {
            String uri = "http://112.30.157.105:8082/IOTWebService/rest/RealNameDataService/UploadAttendanceInfo?access_token=a7d3185996880cd94d965b680feb247b";
            PostMethod postMethod = new PostMethod(uri);
            postMethod.setRequestHeader("content-type", MediaType.APPLICATION_FORM_URLENCODED_VALUE);
            NameValuePair[] nameValuePairs = {
                    new NameValuePair("params", "" +
                            "{" +
                            "      \"unifiedProjectCode\":\"03ae96c7-0a4f-4a55-b926-4a9335ad13be\"," +
                            "      \"idCardNumber\":\"210202198506021378\"," +
                            "      \"attendanceDate\":\"2020-08-08 08:00:00\"," +
                            "      \"direction\":\"direction\"," +
                            "      \"image\":\"1\"," +
                            "      \"deviceSN\":\"ZXHJSB0810\"," +
                            "      \"dataTimeStamp\":\"1591231369050\"," +
                            "      \"temparature\":\"38\"" +
                            "}")
            };
            postMethod.setRequestBody(nameValuePairs);
            HttpClient httpClient = new HttpClient();
            int responseCode = httpClient.executeMethod(postMethod);
            System.out.println("响应码：" + responseCode);
            String responseBodyAsString = postMethod.getResponseBodyAsString();
            System.out.println(responseBodyAsString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*@Test
    public void post3() throws Exception{
        try {
            String uri = "http://112.30.157.105:8082/IOTWebService/rest/EnvironmentDataService/PushRealTimeInfo?access_token=a7d3185996880cd94d965b680feb247b";
            PostMethod postMethod = new PostMethod(uri);
            postMethod.setRequestHeader("content-type", MediaType.APPLICATION_FORM_URLENCODED_VALUE);
            NameValuePair[] nameValuePairs = {
                    new NameValuePair("params", "" +
                            "{" +
                            "    \"unifiedProjectCode\":\"03ae96c7-0a4f-4a55-b926-4a9335ad13be\"," +
                            "    \"dataTimeStamp\":\"1591231369050\"," +
                            "    \"deviceFactory\":\"GTXD实施\"," +
                            "    \"deviceSN\":\"ZXHJSB0810\"," +
                            "    \"tsp\":\"60\"," +
                            "    \"pressure\":\"60\"," +
                            "    \"windDirection\":\"90\"," +
                            "    \"windSpeed\":\"30\"," +
                            "    \"windLevel\":\"4\"," +
                            "    \"temperature\":\"30\"," +
                            "    \"humidity\":\"50\"," +
                            "    \"noise\":\"40\"," +
                            "    \"pm10\":\"100\"," +
                            "    \"pm25\":\"100\"," +
                            "    \"atmospheric\":\"12\"," +
                            "    \"direction\":\"12\"," +
                            "    \"date\":\"2020-08-30\"," +
                            "    \"time\":\"09:04:04\"," +
                            "    \"protocolVer\":\"protocolVer\"," +
                            "    \"otherField\":\"\"" +
                            "}")
            };
            postMethod.setRequestBody(nameValuePairs);
            HttpClient httpClient = new HttpClient();
            int responseCode = httpClient.executeMethod(postMethod);
            System.out.println("响应码：" + responseCode);
            String responseBodyAsString = postMethod.getResponseBodyAsString();
            System.out.println(responseBodyAsString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/

}

    效果图

    在这里插入图片描述

    收起
    展开全文

  • Jmeter测试java请求

     千次阅读 2018-04-02 10:59:24
    写了一个jdbc request上来就根据手机号 将数据库的记录清除,但是现在的数据库手机号是加密之后的手机号,直接传一个明文的手机号是不行的,所以在调用之前要对手机号进行加密，查阅资料发现有Bean shell 和java ...

    源代码下载地址：点此下载

    之前压力测试的是注册功能的接口,写了一个jdbc request上来就根据手机号 将数据库的记录清除,但是现在的数据库手机号是加密之后的手机号,直接传一个明文的手机号是不行的,所以在调用之前要对手机号进行加密，查阅资料发现有Bean shell 和java request的两种方式,先打算使用java request方式进行压力测试。

    先写一个简单的小demo,测试两个数相加

    1.创建一个Java工程

    2.导包

    将JMeter的lib目录下 包括ext 和 junit 中的jar文件添加到工程中 尤其是ext中的ApacheJMeter_core.jar，ApacheJMeter_java.jar都是必须的，有的不是
    myeclipse创建工程,导入jar包就不再说了,这里提供 idea中创建java普通工程,添加jar包,并将代码打成jar包的参考：点此查看

    3.重写jmeter方法JavaTest.java

    创建一个类并实现JavaSamplerClient接口或继承AbstractJavaSamplerClient，并重写方法。 
    package com.test;


import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.protocol.java.sampler.AbstractJavaSamplerClient;
import org.apache.jmeter.protocol.java.sampler.JavaSamplerContext;
import org.apache.jmeter.samplers.SampleResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * @author: wangsaichao
 * @date: 2017/12/13
 * @description:
 */
public class JavaTest extends AbstractJavaSamplerClient {


    private static final Logger logger = LoggerFactory.getLogger(JavaTest.class);


    private String num1;
    private String num2;


    /**
     * 这个方法是用来自定义java方法入参的
     * params.addArgument("num1","");表示入参名字叫num1，默认值为空。
     * @return
     */
    @Override
    public Arguments getDefaultParameters() {
        Arguments params = new Arguments();
        params.addArgument("num1", "");
        params.addArgument("num2", "");
        return params;
    }


    /**
     * 每个线程测试前执行一次，做一些初始化工作
     * 获取输入的参数,赋值给变量,参数也可以在下面的runTest方法中获取,这里是为了展示该方法的作用
     * @param arg0
     */
    @Override
    public void setupTest(JavaSamplerContext arg0) {
        num1 = arg0.getParameter("num1");
        num2 = arg0.getParameter("num2");
    }


    /**
     * 真正执行逻辑的方法
     * @param arg0
     * @return
     */
    @Override
    public SampleResult runTest(JavaSamplerContext arg0) {
        SampleResult sr = new SampleResult();
        sr.setSamplerData("请求参数num1："+num1+"\n请求参数num2："+num2);


        logger.info("请求参数num1：{} 请求参数num2：{}",num1,num2);


        try {
            // jmeter 开始统计响应时间标记
            sr.sampleStart();


            int sum = Integer.parseInt(num1)+Integer.parseInt(num2);


            // 通过下面的操作就可以将被测方法的响应输出到Jmeter的察看结果树中的响应数据里面了。
            sr.setResponseData("结果是："+sum, "utf-8");
            logger.info("结果是：{}",sum);
            sr.setDataType(SampleResult.TEXT);


            //设置响应执行成功
            sr.setSuccessful(true);
        } catch (Throwable e) {
            //有异常,执行失败
            sr.setSuccessful(false);
            e.printStackTrace();
        } finally {
            // jmeter 结束统计响应时间标记
            sr.sampleEnd();
        }
        return sr;
    }




    /**
     * 测试结束后调用
     * @param arg0
     */
    @Override
    public void teardownTest(JavaSamplerContext arg0) {


    }


    /**
     * main方法测试程序是否可用,打包时 注释掉
     * @param args
     */
//    public static void main(String[] args) {
//        Arguments params = new Arguments();
//        //设置参数，并赋予默认值1
//        params.addArgument("num1", "1");
//        //设置参数，并赋予默认值2
//        params.addArgument("num2", "2");
//        JavaSamplerContext arg0 = new JavaSamplerContext(params);
//        JavaTest test = new JavaTest();
//        test.setupTest(arg0);
//        test.runTest(arg0);
//        test.teardownTest(arg0);
//    }


}
    参数介绍：
              public Arguments getDefaultParameters()；可选，定义可用参数及默认值；  
              public void setupTest(JavaSamplerContext arg0)：可选，测试前执行，做一些初始化工作；  
              public SampleResult runTest(JavaSamplerContext arg0)；必选，实现自定义请求；  
              public void teardownTest(JavaSamplerContext arg0)：可选，测试结束时调用；

    4.先使用main方法测试

    使用main方法测试,报以下异常

    1.Intellij idea 出现错误 error:java: 无效的源发行版: 9
    解决方法：idea默认给使用了jdk9的编译
    ①.点击File ->Project Structure...->Project 将9改成8

    ②.点击File ->Project Structure...->Modules 将9改成8


    2.然后再次运行main报以下异常

    ERROR StatusLogger No log4j2 configuration file found. Using default configuration: logging only errors to the console. Set system property 'org.apache.logging.log4j.simplelog.StatusLogger.level' to TRACE to show Log4j2 internal initialization logging.

    解决方法：在classpath下添加log4j2.xml，内容如下 
    <?xml version="1.0" encoding="UTF-8"?>


<configuration status="error">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="trace" onMatch="ACCEPT" onMismatch="DENY"/>
            <!--这个都知道是输出日志的格式-->
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </Console>
        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
        <File name="log" fileName="log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>


        <!--这个会打印出所有的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
        </RollingFile>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <!--建立一个默认的root的logger-->
        <root level="trace">
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="Console"/>
        </root>


    </loggers>
</configuration>

    3.再次执行main方法,成功

    5.将写好的代码,打成jar包并放到jmeter 的 lib/ext目录下

    记得把所有额外的（自定义协议依赖的，非jmeter的）依赖包放到jmeter环境变量中

    6.重启jmeter测试

    创建java Sampler选择刚定义好的测试类，如下图：

    创建线程组：右击测试计划 -> 添加 ->Threads(User) -> 线程组
    创建java request：右击线程组 -> 添加 -> Sampler -> java请求
    添加查看结果数：右击线程组 -> 添加 -> 监听器 -> 查看结果数

    7.测试,结果如下图


    最后,就可以根据正则表达式,提取值给其他方法使用了。


    收起
    展开全文

  • java通过HTTP调用接口（Get请求和Post请求）

     2019-03-29 11:40:12
    java调用HTTP接口（Get请求和Post请求）
    收起

  • jmeter教程（六）：java请求

     千次阅读 2018-12-06 17:05:58
    而java请求，也是在执行一段代码，只不过代码布署在本地，需要我们自己实现代码的逻辑。利用java请求，可以很方便地实现你想要的需求，当然，前提是你要会java。先看看java请求的具体实现吧，打开eclipse，新建一个...
    收起

  • java发送http/https请求(get/post)Demo,亲测可用

     2019-02-14 17:05:11
    java发送http/https请求(get/post)代码,java 通过发送json,post请求,返回json数据的方法 java 通过发送json,post请求,返回json数据的方法
    收起

  • java 请求头设置header

     千次阅读 2019-11-18 17:58:17
    直接上代码 public static JSONObject ******(String url, String id)throws Exception { HttpGet httpGet = new HttpGet(); CloseableHttpClient httpclient = HttpClients.createDefault(); List <Nam...
    收起

  • jmeter的java请求(socket接口)

     千次阅读 2019-04-03 16:11:03
    socket简介:网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一...在Java环境下，Socket编程主要是指基于...
    收起
    jmeter socket

  • java请求https，在本地可以，在服务器端请求失败

     2017-04-14 02:48:58
    java请求https，在本地可以，在服务器端请求失败，是服务器端失败哦！ 自己的前提是请求的url是正确的。 附上https请求代码，请大神一看： ``` public static JSONObject httpRequest(String requestUrl, String...
    收起
    https 服务器

  • jmeter编写java请求脚本压测（一）

     千次阅读 2020-01-09 15:52:22
    3.2.1 jmeter并发，注释链接服务的打印，不然打印结果也会被搭理自动请求，服务会提示有误，报错如图： 解决方案： 4.结果分析 下游最大调用量20万/min :adsearch→zzsearch/zzqr  最大响应时间...
    收起

  • java请求返回406错误的原因及解决情况

     万次阅读 2018-07-21 19:14:36
    1、请求的返回的页面是.html后缀结尾的，并且你返回了Json对象。此时.html并不会解析该对象，所以报错。这个时候可以在web.xml改一下拦截的页面的后缀。 2、缺少Json相应的包：jackson-annotations-2.4.0.jar、...
    收起

  • java 请求https get 接口证书验证问题

     千次阅读 2018-12-19 14:55:37
    1，通过重新定义X509TrustManager证书管理器可以解决相关问题。 @Test public void testToken() throws KeyManagementException, ... //采用绕过验证的方式处理https请求 SSLContext ssl...
    收起

  • java 发送https 请求 证书

     2014-11-21 17:24:34
    java发送https请求,解决了数组证书的问题，所依赖的jar都有
    收起

  • JAVA请求url并获取返回数据

     千次阅读 2018-04-09 09:53:08
    方法：//parm：请求的url链接 返回的是json字符串 public static String getURLContent(String urlStr) { //请求的url URL url = null; //请求的输入流 BufferedReader in = null; //输入流的缓冲 ...
    收起

  • Jmeter测试Java请求示例

     万次阅读 2016-07-11 16:57:21
    1.创建一个Java工程； 2.将JMeter的lib目录下的jar文件添加进此工程的Build Path； ApacheJMeter_core.jar(必须)、ApacheJMeter_java.jar(必须)、avalon-framework-4.1.4.jar、jorphan.jar、logkit-2.0.jar ...
    收起

  • java请求https接口，connection reset

     2016-08-25 13:04:35
    nginx下配好https证书，java 请求https接口会reset。tomcat下配好证书，就没有问题。
    收起
    https nginx

  • Java实现post请求

     千次阅读 2022-02-09 11:20:17
    post请求代码
    收起
    http 开发语言

  • JAVA请求头和响应头各字段意思

     千次阅读 2018-01-30 20:40:46
    1.首先看看浏览器中的请求格式中的请求头，以及服务器的响应格式的响应头。 2.那么请求头中的字段都是什么意思呢？  以下是一张在浏览器中随机截图的一张请求，看看内部字段都有哪些    意思如下： ...
    收起
    JAVAEE JAVAWEB

  • java请求第三方接口

     万次阅读 2016-01-21 16:49:51
    最近工作遇到了一个需要请求第三方接口的项目，项目没有写好的框架，需要手写一个请求方法。code的时候发现一个身份验证的方法很常用，于是整理出了一个验证生成签名的方法，用作以后参考。
    收起

  • Java请求网络图片返回流

     千次阅读 2014-12-19 16:09:56
    HttpURLConnection方式获取图片以及返回的文本
    收起
    图片

  • java发送http/https请求(get/post)代码

     热门讨论 2016-12-02 15:19:05
    自己项目里的，可用
    收起
    https

  • Java 请求https接口不需要安装证书

     千次阅读 2017-05-25 16:50:17
    Java 请求https接口不需要安装证书，获取到信任的cilent
    收起

  • java发送https请求的例子

     热门讨论 2013-10-31 16:18:51
    java发送https请求的例子
    收起

  • jmeter中java请求中怎么设置参数，依据是什么

     2016-09-10 07:44:23
    jmeter中java请求中怎么设置参数，依据是什么，不懂设置参数的依据
    收起

  • java 请求url加时间戳有什么用

     千次阅读 2016-12-23 15:00:33
    1.由于浏览器会对同一 url 的图像进行缓存，向减少服务器端的请求次数，提高浏览性能 随机数就是让每次点击刷新验证码的时候请求的 URL 路径都不同。告诉浏览器上个图片已经失效了，需要重新向服务器上请求新的图片...
    收起

  • Java Http请求工具类

     千次阅读 2021-10-14 11:50:47
    在对接第三方接口时，需要进行数据交互，于是写了一个 Java 的 Http 请求工具类，该工具类可以调用 Get 请求或者 POST 请求。 根据自己业务需求灵活修改 直接上代码： package com.file.license.utils; import org....
    收起
    http 开发工具

  • java请求接口返回值与跳转页面问题

     千次阅读 2016-10-10 10:19:28
    两种请求方式：form表单提交与ajax异步请求（或直接post） 一：form提交  可以在后台跳转页面，没有返回值，后台接口中直接用返回值即可跳转，如请求 test.htm接口：   @RequestMapping("/test.htm")  private ...
    收起
    异步 ajax 接口

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,690,588
精华内容 676,235
热门标签
关键字：

java请求

java 订阅
友情链接： tspmatlab.rar