使用 Rust std 标准库编写一个简单的 Web 服务

jetsung

使用 Rust std 标准库编写一个简单的 Web 服务

// 写一个简单网页服务器,直接返回一个字符串给请求的浏览器

use std::net::TcpListener;
use std::net::TcpStream;
use std::io::prelude::*;

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    for stream in listener.incoming() {
        let stream = stream.unwrap();
        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    stream.read(&mut buffer).unwrap();
    println!("Request: {}", String::from_utf8_lossy(&buffer[..]));
}

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").expect("Could not bind to 127.0.0.1:8080");
    println!("Server listening on http://localhost:8080");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }
            Err(e) => {
                eprintln!("Error: {}", e);
            }
        }
    }
}

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    stream.read(&mut buffer).unwrap();

    println!("Request: {}", String::from_utf8_lossy(&buffer[..]));

    let response = "HTTP/1.1 200 OK\r\n\r\nHello, world!";
    stream.write(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

use std::io::{prelude::*, BufReader};
use std::net::{TcpListener, TcpStream};

fn handle_client(mut stream: TcpStream) {
    let mut reader = BufReader::new(&stream);
    let mut buffer = String::new();

    // 读取请求头
    reader.read_line(&mut buffer).unwrap();
    println!("Request header: {}", buffer);

    // 响应 HTTP 头
    let response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 13\r\n\r\nHello, World!";
    stream.write_all(response.as_bytes()).unwrap();
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:3000").unwrap();
    println!("Listening on http://127.0.0.1:3000");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => handle_client(stream),
            Err(e) => eprintln!("Error: {}", e),
        }
    }
}

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

fn main() {
    // Create a new TCP listener on port 3000
    let listener = TcpListener::bind("127.0.0.1:3000").expect("Failed to bind");

    println!("Listening on http://localhost:3000");

    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                handle_client(&mut stream);
            }
            Err(e) => {
                eprintln!("Error: {}", e);
            }
        }
    }
}

fn handle_client(stream: &mut TcpStream) {
    let mut buffer = [0 as u8; 1024]; // Buffer to store incoming data

    match stream.read(&mut buffer) {
        Ok(size) => {
            // Parse HTTP request
            if !buffer.starts_with(b"GET / HTTP/1.1\r\n") {
                write!(stream, "HTTP/1.1 404 Not Found\r\nContent-Length: 9\r\n\r\nNot Found").unwrap();
            } else {
                // Construct an HTTP response
                let response = "HTTP/1.1 200 OK\r\n\
                                Content-Type: text/html; charset=utf-8\r\n\
                                Content-Length: 13\r\n\
                                \r\n\
                                Hello World!";
                stream.write(response.as_bytes()).unwrap();
            }
        }
        Err(e) => {
            eprintln!("Failed to read from stream: {}", e);
        }
    }

    // Ensure the buffer is clear for new connections
    stream.flush().unwrap();
}

   use std::net::{TcpListener, TcpStream};
   use std::io::{Read, Write};
   use std::thread;

   fn handle_client(mut stream: TcpStream) {
       let mut buffer = [0 as u8; 512];
       stream.read(&mut buffer).expect("Failed to read from stream");

       println!("Request: {}", String::from_utf8_lossy(&buffer[..]));

       let response = "HTTP/1.1 200 OK\r\n\r\nHello, World!";
       stream.write(response.as_bytes()).unwrap();
       stream.flush().unwrap();
   }

   fn main() {
       let listener = TcpListener::bind("127.0.0.1:8080").expect("Failed to bind");

       println!("Server running at http://127.0.0.1:8080/");

       for stream in listener.incoming() {
           match stream {
               Ok(stream) => {
                   thread::spawn(move || {
                       handle_client(stream)
                   });
               }
               Err(e) => {
                   eprintln!("Error: {}", e);
               }
           }
       }
   }

use std::net::TcpListener;
use std::thread;
use std::io::prelude::*;

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
    println!("Listening on http://127.0.0.1:8080");

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        thread::spawn(move || {
            handle_connection(stream);
        });
    }
}

fn handle_connection(mut stream: std::net::TcpStream) {
    let mut buffer = [0; 1024];
    stream.read(&mut buffer).unwrap();

    let response = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n<!DOCTYPE html>\n<html lang=\"en\">\n<head><title>Simple Web 
Server</title></head>\n<body><h1>Hello, world!</h1></body>\n</html>";
    stream.write(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle_connection(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    stream.read(&mut buffer).unwrap();

    let get = b"GET / HTTP/1.1\r\n";

    let (status_line, contents) = if buffer.starts_with(get) {
        ("HTTP/1.1 200 OK\r\n\r\n", "Hello, world!")
    } else {
        ("HTTP/1.1 404 NOT FOUND\r\n\r\n", "Not Found")
    };

    let response = format!("{}{}", status_line, contents);
    stream.write(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
    println!("Listening on http://127.0.0.1:8080");

    for stream in listener.incoming() {
        let stream = stream.unwrap();

        thread::spawn(move || {
            handle_connection(stream);
        });
    }
}

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 512];

    // Read data from the client
    match stream.read(&mut buffer) {
        Ok(size) => {
            // Convert bytes to string and check for "GET / HTTP/1.1"
            if String::from_utf8_lossy(&buffer[..size]).starts_with("GET / HTTP/1.1") {
                let response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\nHello, World!";

                // Write the response to the client
                stream.write_all(response.as_bytes()).unwrap();
            } else {
                let response = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: 9\r\n\r\nNot Found";

                // Write the response to the client
                stream.write_all(response.as_bytes()).unwrap();
            }
        },
        Err(_) => (),
    }
}

fn main() {
    // Create a TCP listener on port 8080
    let listener = TcpListener::bind("127.0.0.1:8080").expect("Failed to bind");

    println!("Listening on http://127.0.0.1:8080");

    // Accept connections in a loop
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }
            Err(_) => continue,
        }
    }
}

use std::{
    io::{prelude::*, BufReader},
    net::{TcpListener, TcpStream},
};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    println!("Server is running on http://127.0.0.1:7878");

    for stream in listener.incoming() {
        let stream = stream.unwrap();
        handle_connection(stream);
    }
}

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&mut stream);
    let http_request: Vec<_> = buf_reader
        .lines()
        .map(|result| result.unwrap())
        .take_while(|line| !line.is_empty())
        .collect();

    println!("Request: {http_request:#?}");

    // Send HTTP response
    let response = b"\
        HTTP/1.1 200 OK\r\n\
        Content-Type: text/html\r\n\
        \r\n\
        <html>\
            <head>\
                <title>Hello Rust</title>\
            </head>\
            <body>\
                <h1>Hello Rust Web Server!</h1>\
            </body>\
        </html>\
        ";
    stream.write(response).unwrap();
        stream.flush().unwrap();
}

10.

use std::{
    io::{Read, Write},
    net::{TcpListener, TcpStream},
    thread,
};

fn main() {
    // 绑定到本地端口 8080
    let listener = TcpListener::bind("127.0.0.1:8080").expect("Failed to bind to port 8080");
    println!("Server running at http://127.0.0.1:8080/");

    // 监听连接
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // 为每个连接创建新线程
                thread::spawn(move || {
                    handle_client(stream);
                });
            }
            Err(e) => {
                eprintln!("Failed to accept connection: {}", e);
            }
        }
    }
}

fn handle_client(mut stream: TcpStream) {
    let mut buffer: [u8; 1024] = [0; 1024];

    // 读取客户端请求
    match stream.read(&mut buffer) {
        Ok(size) => {
            // 解析请求路径
            let request = String::from_utf8_lossy(&buffer[..size]);
            let response = if request.starts_with("GET / HTTP/1.1") {
                // 返回 200 OK 响应
                "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: 13\r\n\r\nHello, World!"
            } else {
                // 返回 404 Not Found 响应
                "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: 9\r\n\r\nNot Found"
            };

            // 发送响应
            if let Err(e) = stream.write_all(response.as_bytes()) {
                eprintln!("Failed to send response: {}", e);
            }
        }
        Err(e) => {
            eprintln!("Failed to read from stream: {}", e);
        }
    }

    // 刷新流
    if let Err(e) = stream.flush() {
        eprintln!("Failed to flush stream: {}", e);
    }
}