HttpClient（联网）

最新推荐文章于 2021-04-23 16:17:43 发布
最新推荐文章于 2021-04-23 16:17:43 发布
阅读量1.5k 收藏
点赞数
分类专栏： extensions/network
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sssssNian/article/details/26570407
版权

例子：

void GameRequest::initRequset(const char* url, cocos2d::CCObject* pTarget, cocos2d::SEL_CallFuncND pSelector)

{

    cocos2d::extension::CCHttpRequest* request = new cocos2d::extension::CCHttpRequest();

    request->setUrl(url);

    //设置为GET请求：kHttpGet

    request->setRequestType(cocos2d::extension::CCHttpRequest::kHttpGet);

    //设置处理响应回调函数

    if(pTarget != NULL && pSelector != NULL){

        request->setResponseCallback(pTarget, pSelector);

    }

    cocos2d::extension::CCHttpClient::getInstance()->setTimeoutForConnect(15);

    cocos2d::extension::CCHttpClient::getInstance()->setTimeoutForRead(15);

    cocos2d::extension::CCHttpClient::getInstance()->send(request);

    int countme = request->retainCount();

    if(countme <= 0)

    {

        CCLOG("=request retaincount==================%d",request->retainCount());

    }    

    request->release();

}


void CoverScene::checkUserNameRequestCallBack(cocos2d::CCNode *sender, void *data)

{

    cocos2d::extension::CCHttpResponse *response = (cocos2d::extension::CCHttpResponse*)data;

    if (!response)

    {

        return;

    }

    //你可以使用: response->request->reqType获取请求类型

    if (0 != strlen(response->getHttpRequest()->getTag()))

    {

        CCLog("%s completed", response->getHttpRequest()->getTag());

    }

    //获取状态码

    int statusCode = response->getResponseCode();

    char statusString[64] = {};

    sprintf(statusString, "HTTP Status Code: %d, tag = %s", statusCode, response->getHttpRequest()->getTag());

    CCLog("response code: %d", statusCode);

    

    if (!response->isSucceed())

    {

        //访问失败获取错误信息

        CCLog("response failed");

        CCLog("error buffer: %s", response->getErrorBuffer());

        return;

    }

    try {

vector::data

指针到  vector 类  的第一个元素成功或为空  vector 的位置。

        std::vector<char> *buffer = response->getResponseData();

        std::string str = std::string(buffer->data(), buffer->size());

        

        Json *dataJson = Json_create(str.data());

        std::cout<<Json_getSize(dataJson)<<std::endl;

        MessageBoxLayer::getMessageBoxPoint()->callMessageBoxRemove();

        if (Json_getSize(dataJson) == 1)

        {

            //账号密码错误

            CCLOG("账号密码错误.........");

            changeToLogin();

        }

        else

        {

            Json *infoDataJson = Json_getItem(dataJson, "data");

            m_accessToken = Json_getItem(infoDataJson,"token")->valuestring;

            GameUser::GetGameUser()->uninqueId = atoll(Json_getItemAt(Json_getItemAt(dataJson, 1),0)->valuestring);

            GameUser::GetGameUser()->platform_user_id = Json_getString(infoDataJson, "platform_user_id", "");//Json_String(infoDataJson, "platform_user_id");

            CoverScene::m_iType = 0;

            getServerListRequest();

        }

    }

    catch (const std::exception& rhs)

    {

        CCLOG("数据异常");

    }

}


#ifndef __CCHTTPREQUEST_H__

#define __CCHTTPREQUEST_H__


#include "cocos2d.h"

#include "ExtensionMacros.h"


#include "HttpRequest.h"

#include "HttpResponse.h"


NS_CC_EXT_BEGIN


/**

 * @addtogroup Network

 * @{

 */



/** @brief Singleton that handles（操控） asynchronous（asyn 异步 chromous 同步） http requests

 * Once the request completed, a callback will issued（发布） in main thread when it provided during make request

 */

class CCHttpClient : public CCObject

{

public:

    /** Return the shared instance **/

    static CCHttpClient *getInstance();// CCHttpClient 是一个单例类

    

    /** Relase the shared instance **/

    static voiddestroyInstance();    

{

    CCAssert(s_pHttpClient, "");

    CCDirector::sharedDirector()->getScheduler()->unscheduleSelector(schedule_selector(CCHttpClient::dispatchResponseCallbacks), s_pHttpClient);

    s_pHttpClient->release();

}

 

    /**

     * Add a get request to task queue

     * @param request a CCHttpRequest object, which includes url, response callback etc.

                      please make sure request->_requestData is clear before calling "send" here.

     * @return NULL

     */

    voidsend(CCHttpRequest* request);//这个用的最多 将CCHttpRequest 加入请求列表  

  

    

    /**

     * Change the connect timeout

     * @param timeout 

     * @return NULL

     */

    inline voidsetTimeoutForConnect(int value) {_timeoutForConnect = value;};//设置连接超时 时间值

    

    /**

     * Get connect timeout

     * @return int

     *

     */

    inline int getTimeoutForConnect() {return _timeoutForConnect;}//获得连接时间

    

    

    /**

     * Change the download timeout

     * @param value

     * @return NULL

     */

    inline voidsetTimeoutForRead(int value) {_timeoutForRead = value;};

    


    /**

     * Get download timeout

     * @return int

     */

    inline intgetTimeoutForRead() {return _timeoutForRead;};

        

private:

    CCHttpClient();//单例类

: _timeoutForConnect(30)

, _timeoutForRead(60)

{

    CCDirector::sharedDirector()->getScheduler()->scheduleSelector(

                    schedule_selector(CCHttpClient::dispatchResponseCallbacks), this, 0, false);

    CCDirector::sharedDirector()->getScheduler()->pauseTarget(this);

}


    virtual ~CCHttpClient();  

//当类是在栈上 类在离开作用域时会调用析构函数释放空间，此时无法调用私有的析构函数

//如果在堆上分配空间，只有在delete时才会调用析构函数。

析构函数私有

当我们规定类只能在堆上分配内存时，就可以将析构函数声明为私有的。

class alloc

{

public:

    alloc():

private:

   ~alloc();

};

 

如果在栈上分配空间，类在离开作用域时会调用析构函数释放空间，此时无法调用私有的析构函数。

如果在堆上分配空间，只有在delete时才会调用析构函数。

 

可以添加一个destroy()函数来释放,从而解决不能在析构函数中添加delete的问题。

class alloc

{

public:

    alloc():

　destroy(){ delete this;} 　

private:

   ~alloc();

};

/


    bool init(void);

    

    /**

     * Init pthread mutex, semaphore, and create new thread for http requests

     * @return bool

     */

    boollazyInitThreadSemphore(); // 私有函数 无需深究   用到了许多额外函数 cpp里写的

{

    if (s_requestQueue != NULL) {

        return true;

    } else {

        

        s_requestQueue = new CCArray();

        s_requestQueue->init();

        

        s_responseQueue = new CCArray();

        s_responseQueue->init();

        

        pthread_mutex_init(&s_requestQueueMutex, NULL);

        pthread_mutex_init(&s_responseQueueMutex, NULL);

        

        pthread_mutex_init(&s_SleepMutex, NULL);

        pthread_cond_init(&s_SleepCondition, NULL);


        pthread_create(&s_networkThread, NULL, networkThread, NULL);

        pthread_detach(s_networkThread);

        

        need_quit = false;

    }

    

    return true;

}


   //Poll function called from main thread to dispatch callbacks when http requests finished 

   // Poll and notify main thread if responses exists in queue

    voiddispatchResponseCallbacks(float delta);  // 分发网络回应  私有函数 无需深究

    

private:

    int _timeoutForConnect;

    int _timeoutForRead;

    

    // std::string reqId;

};


// end of Network group

/// @}


NS_CC_EXT_END


#endif //__CCHTTPREQUEST_H__
.cpp

         作用域 生存期 static extern..........         

下面的 static修饰的函数 生存期全局 作用域内部 外部无法通过extern使用


#include "HttpClient.h"

// #include "platform/CCThread.h"


#include <queue>

#include <pthread.h>

#include <errno.h>


#include "curl/curl.h"


NS_CC_EXT_BEGIN


static pthread_t        s_networkThread;

static pthread_mutex_t  s_requestQueueMutex;

static pthread_mutex_t  s_responseQueueMutex;


static pthread_mutex_ts_SleepMutex;

static pthread_cond_ts_SleepCondition;


static unsigned long    s_asyncRequestCount = 0;


#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

typedef int int32_t;

#endif


static bool need_quit = false;


static CCArray* s_requestQueue = NULL;

static CCArray* s_responseQueue = NULL;


static CCHttpClient *s_pHttpClient = NULL; // pointer to singleton


static char s_errorBuffer[CURL_ERROR_SIZE];


typedef size_t (*write_callback)(void *ptr, size_t size, size_t nmemb, void *stream);


// Callback function used by libcurl for collect response data

static size_t writeData(void *ptr, size_t size, size_t nmemb, void *stream)

{

    std::vector<char> *recvBuffer = (std::vector<char>*)stream;

    size_t sizes = size * nmemb;

    

    // add data to the end of recvBuffer

    // write data maybe called more than once in a single request

    recvBuffer->insert(recvBuffer->end(), (char*)ptr, (char*)ptr+sizes);

    

    return sizes;

}


// Callback function used by libcurl for collect header data

static size_t writeHeaderData(void *ptr, size_t size, size_t nmemb, void *stream)

{

    std::vector<char> *recvBuffer = (std::vector<char>*)stream;

    size_t sizes = size * nmemb;

    

    // add data to the end of recvBuffer

    // write data maybe called more than once in a single request

    recvBuffer->insert(recvBuffer->end(), (char*)ptr, (char*)ptr+sizes);

    

    return sizes;

}



static int processGetTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode, write_callback headerCallback, void *headerStream);

static int processPostTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode, write_callback headerCallback, void *headerStream);

static int processPutTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode, write_callback headerCallback, void *headerStream);

static int processDeleteTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *errorCode, write_callback headerCallback, void *headerStream);

// int processDownloadTask(HttpRequest *task, write_callback callback, void *stream, int32_t *errorCode);



// Worker thread

static void* networkThread(void *data)

{    

    CCHttpRequest *request = NULL;

    

    while (true) 

    {

        if (need_quit)

        {

            break;

        }

        

        // step 1: send http request if the requestQueue isn't empty

        request = NULL;

        

        pthread_mutex_lock(&s_requestQueueMutex); //Get request task from queue

        if (0 != s_requestQueue->count())

        {

            request = dynamic_cast<CCHttpRequest*>(s_requestQueue->objectAtIndex(0));

            s_requestQueue->removeObjectAtIndex(0);  

            // request's refcount = 1 here

        }

        pthread_mutex_unlock(&s_requestQueueMutex);

        

        if (NULL == request)

        {

       // Wait for http request tasks from main thread

       pthread_cond_wait(&s_SleepCondition, &s_SleepMutex);

            continue;

        }

        

        // step 2: libcurl sync access

        

        // Create a HttpResponse object, the default setting is http access failed

        CCHttpResponse *response = new CCHttpResponse(request);

        

        // request's refcount = 2 here, it's retained by HttpRespose constructor

        request->release();

        // ok, refcount = 1 now, only HttpResponse hold it.

        

        int32_t responseCode = -1;

        int retValue = 0;


        // Process the request -> get response packet

        switch (request->getRequestType())

        {

            case CCHttpRequest::kHttpGet: // HTTP GET

                retValue = processGetTask(request,

                                          writeData, 

                                          response->getResponseData(), 

                                          &responseCode,

                                          writeHeaderData,

                                          response->getResponseHeader());

                break;

            

            case CCHttpRequest::kHttpPost: // HTTP POST

                retValue = processPostTask(request,

                                           writeData, 

                                           response->getResponseData(), 

                                           &responseCode,

                                           writeHeaderData,

                                           response->getResponseHeader());

                break;


            case CCHttpRequest::kHttpPut:

                retValue = processPutTask(request,

                                          writeData,

                                          response->getResponseData(),

                                          &responseCode,

                                          writeHeaderData,

                                          response->getResponseHeader());

                break;


            case CCHttpRequest::kHttpDelete:

                retValue = processDeleteTask(request,

                                             writeData,

                                             response->getResponseData(),

                                             &responseCode,

                                             writeHeaderData,

                                             response->getResponseHeader());

                break;

            

            default:

                CCAssert(true, "CCHttpClient: unkown request type, only GET and POSt are supported");

                break;

        }

                

        // write data to HttpResponse

        response->setResponseCode(responseCode);

        

        if (retValue != 0) 

        {

            response->setSucceed(false);

            response->setErrorBuffer(s_errorBuffer);

        }

        else

        {

            response->setSucceed(true);

        }


        

        // add response packet into queue

        pthread_mutex_lock(&s_responseQueueMutex);

        s_responseQueue->addObject(response);

        pthread_mutex_unlock(&s_responseQueueMutex);

        

        // resume dispatcher selector

        CCDirector::sharedDirector()->getScheduler()->resumeTarget(CCHttpClient::getInstance());

    }

    

    // cleanup: if worker thread received quit signal, clean up un-completed request queue

    pthread_mutex_lock(&s_requestQueueMutex);

    s_requestQueue->removeAllObjects();

    pthread_mutex_unlock(&s_requestQueueMutex);

    s_asyncRequestCount -= s_requestQueue->count();

    

    if (s_requestQueue != NULL) {

        

        pthread_mutex_destroy(&s_requestQueueMutex);

        pthread_mutex_destroy(&s_responseQueueMutex);

        

        pthread_mutex_destroy(&s_SleepMutex);

        pthread_cond_destroy(&s_SleepCondition);


        s_requestQueue->release();

        s_requestQueue = NULL;

        s_responseQueue->release();

        s_responseQueue = NULL;

    }


    pthread_exit(NULL);

    

    return 0;

}


//Configure curl's timeout property

static bool configureCURL(CURL *handle)

{

    if (!handle) {

        return false;

    }

    

    int32_t code;

    code = curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, s_errorBuffer);

    if (code != CURLE_OK) {

        return false;

    }

    code = curl_easy_setopt(handle, CURLOPT_TIMEOUT, CCHttpClient::getInstance()->getTimeoutForRead());

    if (code != CURLE_OK) {

        return false;

    }

    code = curl_easy_setopt(handle, CURLOPT_CONNECTTIMEOUT, CCHttpClient::getInstance()->getTimeoutForConnect());

    if (code != CURLE_OK) {

        return false;

    }

    curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 0L);

    curl_easy_setopt(handle, CURLOPT_SSL_VERIFYHOST, 0L);


    return true;

}


class CURLRaii

{

    /// Instance of CURL

    CURL *m_curl;

    /// Keeps custom header data

    curl_slist *m_headers;

public:

    CURLRaii()

        : m_curl(curl_easy_init())

        , m_headers(NULL)

    {

    }


    ~CURLRaii()

    {

        if (m_curl)

            curl_easy_cleanup(m_curl);

        /* free the linked list for header data */

        if (m_headers)

            curl_slist_free_all(m_headers);

    }


    template <class T>

    bool setOption(CURLoption option, T data)

    {

        return CURLE_OK == curl_easy_setopt(m_curl, option, data);

    }


    /**

     * @brief Inits CURL instance for common usage

     * @param request Null not allowed

     * @param callback Response write callback

     * @param stream Response write stream

     */

    bool init(CCHttpRequest *request, write_callback callback, void *stream, write_callback headerCallback, void *headerStream)

    {

        if (!m_curl)

            return false;

        if (!configureCURL(m_curl))

            return false;


        /* get custom header data (if set) */

      std::vector<std::string> headers=request->getHeaders();

        if(!headers.empty())

        {

            /* append custom headers one by one */

            for (std::vector<std::string>::iterator it = headers.begin(); it != headers.end(); ++it)

                m_headers = curl_slist_append(m_headers,it->c_str());

            /* set custom headers for curl */

            if (!setOption(CURLOPT_HTTPHEADER, m_headers))

                return false;

        }


        return setOption(CURLOPT_URL, request->getUrl())

                && setOption(CURLOPT_WRITEFUNCTION, callback)

                && setOption(CURLOPT_WRITEDATA, stream)

                && setOption(CURLOPT_HEADERFUNCTION, headerCallback)

                && setOption(CURLOPT_HEADERDATA, headerStream);

        

    }


    /// @param responseCode Null not allowed

    bool perform(int *responseCode)

    {

        if (CURLE_OK != curl_easy_perform(m_curl))

            return false;

        CURLcode code = curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, responseCode);

        if (code != CURLE_OK || *responseCode != 200)

            return false;

        

        // Get some mor data.

        

        return true;

    }

};


//Process Get Request

static int processGetTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode, write_callback headerCallback, void *headerStream)

{

    CURLRaii curl;

    bool ok = curl.init(request, callback, stream, headerCallback, headerStream)

            && curl.setOption(CURLOPT_FOLLOWLOCATION, true)

            && curl.perform(responseCode);

    return ok ? 0 : 1;

}


//Process POST Request

static int processPostTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode, write_callback headerCallback, void *headerStream)

{

    CURLRaii curl;

    bool ok = curl.init(request, callback, stream, headerCallback, headerStream)

            && curl.setOption(CURLOPT_POST, 1)

            && curl.setOption(CURLOPT_POSTFIELDS, request->getRequestData())

            && curl.setOption(CURLOPT_POSTFIELDSIZE, request->getRequestDataSize())

            && curl.perform(responseCode);

    return ok ? 0 : 1;

}


//Process PUT Request

static int processPutTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode, write_callback headerCallback, void *headerStream)

{

    CURLRaii curl;

    bool ok = curl.init(request, callback, stream, headerCallback, headerStream)

            && curl.setOption(CURLOPT_CUSTOMREQUEST, "PUT")

            && curl.setOption(CURLOPT_POSTFIELDS, request->getRequestData())

            && curl.setOption(CURLOPT_POSTFIELDSIZE, request->getRequestDataSize())

            && curl.perform(responseCode);

    return ok ? 0 : 1;

}


//Process DELETE Request

static int processDeleteTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode, write_callback headerCallback, void *headerStream)

{

    CURLRaii curl;

    bool ok = curl.init(request, callback, stream, headerCallback, headerStream)

            && curl.setOption(CURLOPT_CUSTOMREQUEST, "DELETE")

            && curl.setOption(CURLOPT_FOLLOWLOCATION, true)

            && curl.perform(responseCode);

    return ok ? 0 : 1;

}


// HttpClient implementation

CCHttpClient* CCHttpClient::getInstance()

{

    if (s_pHttpClient == NULL) {

        s_pHttpClient = new CCHttpClient();

    }

    

    return s_pHttpClient;

}


void CCHttpClient::destroyInstance()

{

    CCAssert(s_pHttpClient, "");

    CCDirector::sharedDirector()->getScheduler()->unscheduleSelector(schedule_selector(CCHttpClient::dispatchResponseCallbacks), s_pHttpClient);

    s_pHttpClient->release();

}


CCHttpClient::CCHttpClient()

: _timeoutForConnect(30)

, _timeoutForRead(60)

{

    CCDirector::sharedDirector()->getScheduler()->scheduleSelector(

                    schedule_selector(CCHttpClient::dispatchResponseCallbacks), this, 0, false);

    CCDirector::sharedDirector()->getScheduler()->pauseTarget(this);

}


CCHttpClient::~CCHttpClient()

{

    need_quit = true;

    

    if (s_requestQueue != NULL) {

   pthread_cond_signal(&s_SleepCondition);

    }

    

    s_pHttpClient = NULL;

}


//Lazy create semaphore & mutex & thread

bool CCHttpClient::lazyInitThreadSemphore()

{

    if (s_requestQueue != NULL) {

        return true;

    } else {

        

        s_requestQueue = new CCArray();

        s_requestQueue->init();

        

        s_responseQueue = new CCArray();

        s_responseQueue->init();

        

        pthread_mutex_init(&s_requestQueueMutex, NULL);

        pthread_mutex_init(&s_responseQueueMutex, NULL);

        

        pthread_mutex_init(&s_SleepMutex, NULL);

        pthread_cond_init(&s_SleepCondition, NULL);


        pthread_create(&s_networkThread, NULL, networkThread, NULL);

        pthread_detach(s_networkThread);

        

        need_quit = false;

    }

    

    return true;

}


//Add a get task to queue

void CCHttpClient::send(CCHttpRequest* request)

{    

    if (false == lazyInitThreadSemphore()) 

    {

        return;

    }

    

    if (!request)

    {

        return;

    }

        

    ++s_asyncRequestCount;

    

    request->retain();

        

    pthread_mutex_lock(&s_requestQueueMutex);

    s_requestQueue->addObject(request);

    pthread_mutex_unlock(&s_requestQueueMutex);

    

    // Notify thread start to work

    pthread_cond_signal(&s_SleepCondition);

}


// Poll and notify main thread if responses exists in queue

void CCHttpClient::dispatchResponseCallbacks(float delta)

{

    // CCLog("CCHttpClient::dispatchResponseCallbacks is running");

    

    CCHttpResponse* response = NULL;

    

    pthread_mutex_lock(&s_responseQueueMutex);

    if (s_responseQueue->count())

    {

        response = dynamic_cast<CCHttpResponse*>(s_responseQueue->objectAtIndex(0));

        s_responseQueue->removeObjectAtIndex(0);

    }

    pthread_mutex_unlock(&s_responseQueueMutex);

    

    if (response)

    {

        --s_asyncRequestCount;

        

        CCHttpRequest *request = response->getHttpRequest();

        CCObject *pTarget = request->getTarget();

        SEL_HttpResponse pSelector = request->getSelector();


        if (pTarget && pSelector) 

        {

            (pTarget->*pSelector)(this, response);

        }

        

        response->release();

    }

    

    if (0 == s_asyncRequestCount) 

    {

        CCDirector::sharedDirector()->getScheduler()->pauseTarget(this);

    }

    

}


NS_CC_EXT_END












sssss年
关注
专栏目录
Android通过HttpURLConnection与HttpClient联网代理网关设置
--------→成人不自在，自在不成人℃ ------------
04-20 4376
Android联网主要使用HttpURLConneciton和HttpClient进行联网，在手机联网的时候，我们优先选择wifi网络，其次在选择移动网络，这里所述移动网络主要指cmwap。 大家都知道cmwap连接需要设置代理地址和端口，那么，android程序中如何设置代理呢？ 1、HttpURLConnection设置代理 //当我们使用的是中国移动的手机网络时，下
HttpClient的异步调用，你造吗？
技术原始积累
06-14 4386
一、前言HttpClient提供了两种I/O模型：经典的java阻塞I/O模型和基于Java NIO的异步非阻塞事件驱动I/O模型。Java中的阻塞I/O是一种高效、便捷的I/O模型，非...
HttpClient联网请求
fanaw的博客
06-25 288
如果在Android Studro 中使用 需要 在build.gradle 中android   {  下 添加 这一行useLibrary 'org.apache.http.legacy'   /** * GET方式请求网络 */ private void httpGet(String name) { // HttpClient得到HttpClient对象 HttpClient
HttpClient4.5 简单入门实例(一)
java的平凡之路
03-16 1274
一、所需要的jar包    httpclient-4.5.jar    httpcore-4.4.1.jar    httpmime-4.5.jar 二、实例 Java代码   package cn.tzz.apache.httpclient;         import java.io.File;   import java.io.IOE
HttpClient的通信
rimuweinuan_的博客
02-24 648
HTTP编程两种方式 GET方式：数据附在网址中，好处是速度快，并可设为书签；不足是传输的数据有限，并且不保密 POST方式：数据封装成表单发送，好处是传输的数据量大，保密；不足是速度稍慢，不能设为书签 1、在AndroidManifest.xml添加网络权限 2、activity_main.xml <LinearLayout xmlns:android="http://sc
httpclient封装获取响应实体_Httpclient 接口自动化
weixin_36190719的博客
12-31 481
好久木写啦！！！好久木写啦！！！心血来潮分享点小白的东西！！！废话少说直接干货！！！本文核心是将如何从数据驱动开始，以报告结尾的形式来实现“很多刚入行朋友们”所需要的接口自动化类型：驱动：excel核心jar：httpclient编译：maven(跟本文所讲有点沾不着边)自动化框架 ：testng(这个支持并发所以实现了并发的方法)报告：ztest(有在之前tester老大哥的开源报告上实现了修改...
HttpClientUtils
AyubLIbra的博客
06-28 1170
package utils; 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.util.ArrayList;
android 联网请求的两种方式HttpURLConnection和HttpClient
03-01
常见的联网请求方式有两种：HttpURLConnection和HttpClient。下面将详细讲解这两种方法，以及它们如何处理POST和GET请求。 **HttpURLConnection** HttpURLConnection是Java标准库提供的类，自Android 2.3（API级别9...
HttpClient 联网接口
to_cm的专栏
11-02 897
联网HTTPCLIENT
android简单联网
12-22
总结，Android简单联网涵盖了HttpURLConnection的基础使用、HttpClient（已弃用）、以及现代库如OkHttp和Volley的应用。理解这些基本概念和工具是构建任何Android网络应用的第一步。随着项目复杂性的增加，你可能还...
C++ 基于libcurl的http客户端
HelloKandy's Blog
12-28 1万+
当使用C++想要实现HTTP客户端时，目前通用的做法就是使用libcurl。本文主要分享的是一个基于libcurl的HTTP封装类，其功能包括：同步的(HTTP/HTTPS)GET、POST请求，以及文件下载和进度报告。 头文件代码： #ifndef __BASE_EASY_CURL_H__ #define __BASE_EASY_CURL_H__ #include #include
HttpClient使用详解
姚佳伟
01-22 1万+
HttpClient:是一个接口 首先需要先创建一个DefaultHttpClient的实例 HttpClient httpClient=new DefaultHttpClient(); 发送GET请求: 先创建一个HttpGet对象,传入目标的网络地址,然后调用HttpClient的execute()方法即可: HttpGet HttpGet=new HttpGet(“http://w
HttpClient的使用教程
weixin_40159122的博客
12-09 1986
一、HttpClient介绍 HTTP协议可能是现在Internet上使用最多最重要的协议了，越来越多的java应用程序需要直接通过HTTP协议来访问网络资源。虽然在JDK的java net包中已经提供了访问HTTP协议的基本功能，但是对于大部分应用程序来说，JDK库本身提供的功能还不够丰富和灵活。HttpClien则可以提供高效的、最新的、功能丰富的支持http协议的客户端编程工具包，并且...
[物联网]4G模块openCPU通信之http通信
slimmm的博客
04-23 3768
1.Http简介 HTTP是Hyper Text Transfer Protocol（超文本传输协议）的缩写。它的发展是万维网协会（World Wide Web Consortium）和Internet工作小组IETF（Internet Engineering Task Force）合作的结果，（他们）最终发布了一系列的RFC，RFC 1945定义了HTTP/1.0版本。其中最著名的就是RFC 2616。RFC 2616定义了今天普遍使用的一个版本——HTTP 1.1。 HTTP协议（HyperText
Httpclient
weixin_43467870的博客
09-08 166
文章简介 分析自己写的代码并总结 get请求 post请求 分析自己写的代码并总结 代码 package com.zhangxiaoguang.utils; import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.List; import java.uti...
Java HttpClient中的三种超时设置区别
z69183787的专栏
09-20 2万+
最近项目中在使用HttpClient有三个超时(connectionRequestTimeout,connectTimeout,socketTimeout)时间理解得不是很透彻，API文档不是很理解，专门写Demo理解了一下。 API的描述如下： /** * Returns the timeout in milliseconds used when requesting a co
httpClient 请求深度封装
zhangpan_soft的博客
09-20 1万+
因为项目需求,需要集成http请求,就采用了非常火的httpclient,因为httpclient需要设置的东西比较多,在开发中,有些人不知道怎么调用,因此对其进行了二次封装,使用起来就简单的多了.废话少说上代码 package com.rjhcsoft.credit.utils.http; import org.apache.http.HttpEntity; import org.apa...
HttpClient超时设置详解
热门推荐
u011191463的专栏
11-29 14万+
HttpClient 4.3。HttpClient这货和Lucene一样，每个版本的API都变化很大，这有点让人头疼。就好比创建一个HttpClient对象吧，每一个版本的都不一样， 3.X是这样的 ? 1 HttpClient httpClient=newDefaultHttpClient(); 4.3
封装C#发送http请求成功后的callback
wangpeng2011314的专栏
02-28 5883
目的其实很简单，是想要封装一个发送http的post请求的函数。 函数参数填url地址、请求参数、以及得到后台相应的回调函数、访问超时时间 形如： public void HttpPost(string url, Dictionary dic , Action callback,int timeout)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值