httplib - HTTP연결

API 사용:

>>> import httplib, urllib

>>> params = urllib.urlencode({'@number': 12524, '@type': 'issue', '@action': 'show'})
>>> headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}

>>> conn = httplib.HTTPConnection("bugs.python.org")
>>> conn.request("POST", "", params, headers)

>>> response = conn.getresponse()
>>> print response.status, response.reason
302 Found

>>> data = response.read()
>>> data
'Redirecting to <a href=" 

>>> conn.close()

HTTPConnection은 서버 위치로 초기화되어야 하며, 의도는 HTTPConnection 표현이며 하나의 위치만 요청할 수 있습니다.
사용자는 conn.request를 호출하여 요청을 시작하기 위한 메서드, 경로, 본문 및 헤더를 지정합니다.
HTTPResponse 응답을 반환하려면 conn.getresponse를 호출하세요.

다른 인터페이스가 있는지 봅시다.
연결: self.sock 속성을 업데이트합니다.
putrequest: 시작 라인과 HOST 및 Accept-Encoding 헤더를 빌드합니다. 이 두 헤더는 http 버전과 관련이 있기 때문입니다.
putheader: 헤더 라인 빌드
endheaders: 시작 줄, 헤더 및 본문을 보냅니다.
닫기: 연결을 닫습니다.
set_tunnel: 터널 설정

HTTPConnection의 인터페이스는 비즈니스 프로세스에서 설계되었음을 알 수 있습니다.
먼저 소켓 연결을 설정하고,
그런 다음 출발선을 만들고,
헤더 빌드,
요청 요청 보내기,
그런 다음 http 응답을 반환합니다.

그런 다음 HTTPSConnection이 HTTPConnection을 기반으로 하는 방법을 확인하십시오.

def connect(self):
    "Connect to a host on a given (SSL) port."
     sock = socket.create_connection((self.host, self.port),
                                     self.timeout, self.source_address)
     if self._tunnel_host:
         self.sock = sock
         self._tunnel()
     self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)

연결 방법을 재정의하고 https는 연결을 설정하기 위해 key_file, cert_file이 필요합니다. 하지만 connect의 매개변수를 사용하는 대신 속성을 통해 클래스의 __init__ 메서드를 통해 전달됩니다.
이 형식은 연결 매개변수 전달보다 낫습니다. 인터페이스 디자인이 많은 기능을 고려한다면 많은 기본 매개변수를 가질 것이기 때문입니다. 그리고 향후 확장에도 좋지 않습니다. 그러나 이 __init__ 메서드는 또한 많은 기본 매개변수를 고려해야 하며 매개변수의 기능은 그렇게 직접적이지 않습니다.

그런 다음 데이터를 보내는 방법을 살펴보겠습니다.

def _output(self, s):
        """Add a line of output to the current request buffer.
        Assumes that the line does *not* end with \\r\
.
        """
        self._buffer.append(s)

self._buffer = [], 요소는 http 헤더의 각 행입니다. _send_output 메서드에서 표준 http 형식으로 형식이 지정됩니다.

def _send_output(self, message_body=None):
        """Send the currently buffered request and clear the buffer.
        Appends an extra \\r\
 to the buffer.
        A message_body may be specified, to be appended to the request.
        """
        self._buffer.extend(("", ""))
        msg = "\r
".join(self._buffer)
        del self._buffer[:]
        # If msg and message_body are sent in a single send() call,
        # it will avoid performance problems caused by the interaction
        # between delayed ack and the Nagle algorithm.
        if isinstance(message_body, str):
            msg += message_body
            message_body = None
        self.send(msg)
        if message_body is not None:
            #message_body was not a string (i.e. it is a file) and
            #we must run the risk of Nagle
            self.send(message_body)

msg 변수가\r을 통해 self._buffer에 의해 연결되고 표준 http 헤더로 형식이 지정된 것을 볼 수 있습니다. 그런 다음 send 메서드를 호출하여 http 헤더와 http 엔터티를 보냅니다.

def send(self, data):
        """Send `data' to the server."""
        if self.sock is None:
            if self.auto_open:
                self.connect()
            else:
                raise NotConnected()
        if self.debuglevel > 0:
            print "send:", repr(data)
        blocksize = 8192
        if hasattr(data,'read') and not isinstance(data, array):
            if self.debuglevel > 0: print "sendIng a read()able"
            datablock = data.read(blocksize)
            while datablock:
                self.sock.sendall(datablock)
                datablock = data.read(blocksize)
        else:
            self.sock.sendall(data)

send 메소드는 소켓에 데이터를 보내는 역할을 합니다. 데이터의 읽기 속성을 지원하며 데이터에서 데이터를 지속적으로 가져와서 보냅니다.

    def putheader(self, header, *values):
        """Send a request header line to the server.
        For example: h.putheader('Accept', 'text/html')
        """
        if self.__state != _CS_REQ_STARTED:
            raise CannotSendHeader()
        hdr = '%s: %s' % (header, '\r
\t'.join([str(v) for v in values]))
        self._output(hdr)

putheader 방법은 간단하며 단순히 헤더를 구성합니다.

    def request(self, method, url, body=None, headers={}):
        """Send a complete request to the server."""
        self._send_request(method, url, body, headers)

_send_request 메소드 정의:

def _send_request(self, method, url, body, headers):
        # Honor explicitly requested Host: and Accept-Encoding: headers.
        header_names = dict.fromkeys([k.lower() for k in headers])
        skips = {}
        if 'host' in header_names:
            skips['skip_host'] = 1
        if 'accept-encoding' in header_names:
            skips['skip_accept_encoding'] = 1
        self.putrequest(method, url, **skips)
        if body is not None and 'content-length' not in header_names:
            self._set_content_length(body)
        for hdr, value in headers.iteritems():
            self.putheader(hdr, value)
        self.endheaders(body)

첫 번째는 putrequest를 호출하여 출발선을 구축하는 것입니다.
그런 다음 putheader를 호출하여 헤더를 빌드합니다.
마지막으로 endheaders를 호출하여 엔터티를 구성하고 보냅니다.

    def getresponse(self, buffering=False):
        "Get the response from the server."
        if self.__state != _CS_REQ_SENT or self.__response:
            raise ResponseNotReady()
        args = (self.sock,)
        kwds = {"strict":self.strict, "method":self._method}
        if self.debuglevel > 0:
            args += (self.debuglevel,)
        if buffering:
            #only add this keyword if non-default, for compatibility with
            #other response_classes.
            kwds["buffering"] = True;
        response = self.response_class(*args, **kwds)
        response.begin()
        assert response.will_close != _UNKNOWN
        self.__state = _CS_IDLE
        if response.will_close:
            # this effectively passes the connection to the response
            self.close()
        else:
            # remember this, so we can tell when it is complete
            self.__response = response
        return response

getresponse 메서드는 self.sock을 사용하여 HTTPResponse 개체를 인스턴스화한 다음 HTTPResponse의 begin 메서드를 호출합니다. HTTPResponse는 주로 소켓을 기반으로 http 응답을 구문 분석하는 역할을 합니다. 나중에 설명합니다.