Rubino presa di programmazione

Rubino offre due livelli di accesso ai servizi di rete, è possibile accedere al sistema operativo sottostante, che consente di ottenere il supporto client e server per i protocolli orientati alla connessione e senza connessione presa di base.

protocolli di Ruby unificati di supporto delle applicazioni di rete, come FTP, HTTP e simili.

Sia superiore o inferiore. rubino fornisce alcune classi di base, in modo da poter utilizzare il protocollo TCP interattivo, UDP, SOCKS, e molti altri protocolli, senza formalità al livello di rete. Queste classi forniscono anche lezioni supplementari, in modo da poter facilmente leggere e scrivere al server.

Avanti, impariamo come programmazione Ruby Socket

Quali sono Sockets

Quando la comunicazione dei dati a livello di applicazione attraverso il livello di trasporto, TCP e UDP esperienza, fornendo servizi per i molteplici problemi legati ai processi di applicazione simultanei. connessioni TCP multipli o più applicazioni attraverso lo stesso processo può richiedere una porta protocollo TCP per trasferire i dati. Al fine di distinguere tra diversi processi di applicazione, e le connessioni, molti sistemi operativi dei computer interagiscono con le applicazioni TCP / IP protocollo e fornisce un'interfaccia chiamata a socket (zoccolo), la distinzione tra la comunicazione in rete e la connettività tra i diversi processi di applicazione per.

Genera presa, ci sono tre parametri principali: indirizzo IP di destinazione del traffico, il protocollo di livello di trasporto (TCP o UDP) utilizzato e il numero di porta. Socket ha lo scopo di "presa". Grazie alla combinazione di questi tre parametri, e di una presa bind "presa", il livello di applicazione e il livello di trasporto può avvenire attraverso l'interfaccia socket, la distinzione tra i processi di comunicazione provenienti da diverse applicazioni o connessioni di rete, servizi di trasmissione dati simultanei.

Analisi Sockets vocabolario:

client Simple

Di seguito attraverso un determinato host e porta a dare una semplice istanza del client, Ruby TCPSocket classe libera fornisce un modo per aprire un socke.

TCPSocket.open (hosname, porto) per aprire una connessione TCP.

Una volta che si apre una connessione socket, è possibile leggere come oggetto IO come si è completato, è necessario chiudere il file il più vicino la connessione.

L'esempio seguente mostra come connettersi a un host specifico, e leggere i dati dal socket, e, infine, chiude il socket:

require 'socket'      # Sockets 是标准库

hostname = 'localhost'
port = 2000

s = TCPSocket.open(hostname, port)

while line = s.gets   # 从 socket 中读取每行数据
  puts line.chop      # 打印到终端
end
s.close               # 关闭 socket 

servizio semplice

Rubino può essere utilizzato classe TCPServer per scrivere un semplice servizio. Tcpserver oggetti sono TCPSocket oggetto factory.

Ora usiamo TCPServer.open (nome host, port) per creare un oggetto TCPServer.

La chiamata successiva TCPServer accettare metodo attende che un client si collega alla porta specificata, e restituisce un oggetto TCPSocket che rappresenta la connessione al client.

require 'socket'               # 获取socket标准库

server = TCPServer.open(2000)  # Socket 监听端口为 2000
loop {                         # 永久运行服务
  client = server.accept       # 等待客户端连接
  client.puts(Time.now.ctime)  # 发送时间到客户端
  client.puts "Closing the connection. Bye!"
  client.close                 # 关闭客户端连接
}

Ora, il codice precedente viene eseguito sul server, visualizzare i risultati.

servizio TCP Multi-client

Su Internet, molti servizi hanno un gran numero di connessioni client.

classe Thread di Ruby può facilmente creare multi-threaded, un thread di esecuzione per le connessioni client, e il thread principale è in attesa di ulteriori collegamenti.

require 'socket'                # 获取socket标准库

server = TCPServer.open(2000)   # Socket 监听端口为 2000
loop {                          # 永久运行服务
  Thread.start(server.accept) do |client|
    client.puts(Time.now.ctime) # 发送时间到客户端
	client.puts "Closing the connection. Bye!"
    client.close                # 关闭客户端连接
  end
}

In questo esempio, presa correre per sempre, e quando server.accept la ricezione di client per connettersi a, viene creato un nuovo thread e iniziare immediatamente l'elaborazione della richiesta. E ora il principale indietro loop di programma e attendere una nuova connessione.

Web browser Piccolo

Siamo in grado di utilizzare la libreria presa di realizzare qualsiasi Internet Protocol. Il codice seguente mostra come ottenere il contenuto della pagina:

require 'socket'
 
host = 'www.w3cschool.cc'     # web服务器
port = 80                           # 默认 HTTP 端口
path = "/index.htm"                 # 想要获取的文件地址

# 这是个 HTTP 请求
request = "GET #{path} HTTP/1.0\r\n\r\n"

socket = TCPSocket.open(host,port)  # 连接服务器
socket.print(request)               # 发送请求
response = socket.read              # 读取完整的响应
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2) 
print body                          # 输出结果

Per ottenere un client web simile, è possibile utilizzare la libreria di pre-costruito di HTTP come Net :: HTTP.

require 'net/http'                  # 我们需要的库
host = 'www.w3cschool.cc'           #  web 服务器
path = '/index.htm'                 # 我们想要的文件 

http = Net::HTTP.new(host)          # 创建连接
headers, body = http.get(path)      # 请求文件
if headers.code == "200"            # 检测状态码
  print body                        
else                                
  puts "#{headers.code} #{headers.message}" 
end

Sopra abbiamo semplicemente introduciamo Ruby in applicazioni socket, ulteriori informazioni, si prega di consultare: librerie Ruby ei metodi della classe Socket