rust构建web服务器

农民  论坛元老 | 2024-11-17 20:19:06 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1586|帖子 1586|积分 4758

单线程服务器

src/main.rs
  1. use std::fs;
  2. use std::io::prelude::*;
  3. use std::net::TcpListener;
  4. use std::net::TcpStream;
  6. fn main() {
  7.     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
  9.     for stream in listener.incoming() {
  10.         let stream = stream.unwrap();
  12.         handle_connection(stream);
  13.     }
  14. }
  16. fn handle_connection(mut stream: TcpStream) {
  17.     // let mut buffer = [0; 1024];
  19.     // stream.read(&mut buffer).unwrap();
  21.     // // String::from_utf8_lossy 将数组切片转成字符串
  22.     // println!("Request: {}", String::from_utf8_lossy(&buffer[..]));
  24.     let mut buffer = [0; 1024];
  25.     stream.read(&mut buffer).unwrap();
  27.     let get = b"GET / HTTP/1.1\r\n"; //获取字符串的字节表示
  29.     if buffer.starts_with(get) {
  30.         let contents = fs::read_to_string("hello.html").unwrap();
  32.         let response = format!(
  33.             "HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
  34.             contents.len(),
  35.             contents
  36.         );
  38.         stream.write(response.as_bytes()).unwrap();
  39.         stream.flush().unwrap();
  40.     } else {
  41.         // 其他请求
  42.         let status_line = "HTTP/1.1 404 NOT FOUND";
  43.         let contents = fs::read_to_string("404.html").unwrap();
  45.         let response = format!(
  46.             "{}\r\nContent-Length: {}\r\n\r\n{}",
  47.             status_line,
  48.             contents.len(),
  49.             contents
  50.         );
  52.         stream.write(response.as_bytes()).unwrap();
  53.         stream.flush().unwrap();
  54.     }
  55. }
  57. // HTTP一个请求有如下格式：CRLF 序列也可以写成 \r\n
  58. // Method Request-URI HTTP-Version CRLF
  59. // headers CRLF
  60. // message-body
  62. // 响应:HTTP/1.1 200 OK\r\n\r\n
复制代码
hello.html
  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="utf-8">
  6.     <title>Hello!</title>
  7. </head>
  9. <body>
  10.     <h1>Hello!</h1>
  11.     <p>Hi from Rust</p>
  12. </body>
  14. </html>
复制代码
404.html
  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="utf-8">
  6.     <title>Hello!</title>
  7. </head>
  9. <body>
  10.     <h1>Oops!</h1>
  11.     <p>Sorry, I don't know what you're asking for.</p>
  12. </body>
  14. </html>
复制代码
重构
  1. use std::fs;
  2. use std::io::prelude::*;
  3. use std::net::TcpListener;
  4. use std::net::TcpStream;
  6. fn main() {
  7.     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
  9.     for stream in listener.incoming() {
  10.         let stream = stream.unwrap();
  12.         handle_connection(stream);
  13.     }
  14. }
  16. fn handle_connection(mut stream: TcpStream) {
  17.     let mut buffer = [0; 1024];
  18.     stream.read(&mut buffer).unwrap();
  19.     let get = b"GET / HTTP/1.1\r\n";
  21.     let (status_line, filename) = if buffer.starts_with(get) {
  22.         ("HTTP/1.1 200 OK", "hello.html")
  23.     } else {
  24.         ("HTTP/1.1 404 NOT FOUND", "404.html")
  25.     };
  27.     let contents = fs::read_to_string(filename).unwrap();
  29.     let response = format!(
  30.         "{}HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
  31.         status_line,
  32.         contents.len(),
  33.         contents
  34.     );
  36.     stream.write(response.as_bytes()).unwrap();
  37.     stream.flush().unwrap();
  38. }
  40. // HTTP一个请求有如下格式：CRLF 序列也可以写成 \r\n
  41. // Method Request-URI HTTP-Version CRLF
  42. // headers CRLF
  43. // message-body
  45. // 响应:HTTP/1.1 200 OK\r\n\r\n
复制代码
多线程服务器


lib.rs
  1. use std::{
  2.     sync::{mpsc, Arc, Mutex},
  3.     thread,
  4. };
  6. pub struct ThreadPool {
  7.     workers: Vec<Worker>,
  8.     sender: mpsc::Sender<Job>,
  9. }
  10. // 持有发送到channal的闭包
  11. // Job是某个特征对象的类型别名
  12. type Job = Box<dyn FnOnce() + Send + 'static>;
  14. impl ThreadPool {
  15.     /// 创建线程池。
  16.     ///
  17.     /// 线程池中线程的数量。
  18.     ///
  19.     /// # Panics
  20.     ///
  21.     /// `new` 函数在 size 为 0 时会 panic。
  22.     pub fn new(size: usize) -> ThreadPool {
  23.         assert!(size > 0);
  25.         let (sender, receiver) = mpsc::channel();
  26.         //Arc 多线程安全的智能指针
  27.         let receiver = Arc::new(Mutex::new(receiver));
  29.         let mut workers = Vec::with_capacity(size);
  31.         for id in 0..size {
  32.             workers.push(Worker::new(id, Arc::clone(&receiver)));
  33.         }
  35.         ThreadPool { workers, sender }
  36.     }
  38.     pub fn execute<F>(&self, f: F)
  39.     where
  40.         F: FnOnce() + Send + 'static,
  41.     {
  42.         let job = Box::new(f);
  44.         self.sender.send(job).unwrap();
  45.     }
  46. }
  47. struct Worker {
  48.     id: usize,
  49.     thread: thread::JoinHandle<()>,
  50. }
  52. impl Worker {
  53.     fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
  54.         let thread = thread::spawn(move || loop {
  55.             // receiver.lock() 获取一个互斥锁,recv()从channel获取一个job
  56.             let job = receiver.lock().unwrap().recv().unwrap();
  58.             println!("Worker {} got a job; executing.", id);
  60.             job();
  61.         });
  63.         Worker { id, thread }
  64.     }
  65. }
复制代码
main.rs
  1. use std::fs;
  2. use std::io::prelude::*;
  3. use std::net::TcpListener;
  4. use std::net::TcpStream;
  6. use std::thread;
  7. use std::time::Duration;
  9. use server::ThreadPool;
  11. fn main() {
  12.     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
  13.     let pool = ThreadPool::new(4);
  15.     for stream in listener.incoming() {
  16.         let stream = stream.unwrap();
  18.         pool.execute(|| {
  19.             handle_connection(stream);
  20.         });
  21.     }
  22. }
  24. fn handle_connection(mut stream: TcpStream) {
  25.     let mut buffer = [0; 1024];
  26.     stream.read(&mut buffer).unwrap();
  28.     let get = b"GET / HTTP/1.1\r\n";
  29.     let sleep = b"GET /sleep HTTP/1.1\r\n";
  31.     let (status_line, filename) = if buffer.starts_with(get) {
  32.         ("HTTP/1.1 200 OK", "hello.html")
  33.     } else if buffer.starts_with(sleep) {
  34.         thread::sleep(Duration::from_secs(5));
  35.         ("HTTP/1.1 200 OK", "hello.html")
  36.     } else {
  37.         ("HTTP/1.1 404 NOT FOUND", "404.html")
  38.     };
  40.     let contents = fs::read_to_string(filename).unwrap();
  42.     let response = format!(
  43.         "{}HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n{}",
  44.         status_line,
  45.         contents.len(),
  46.         contents
  47.     );
  49.     stream.write(response.as_bytes()).unwrap();
  50.     stream.flush().unwrap();
  51. }
复制代码
优雅停机与清算

lib.rs
  1. use std::{
  2.     sync::{mpsc, Arc, Mutex},
  3.     thread,
  4. };
  6. pub struct ThreadPool {
  7.     workers: Vec<Worker>,
  8.     sender: mpsc::Sender<Message>,
  9. }
  10. // 持有发送到channal的闭包
  11. // Job是某个特征对象的类型别名
  12. type Job = Box<dyn FnOnce() + Send + 'static>;
  14. // 向线程发送信号使其停止接收任务
  15. enum Message {
  16.     NewJob(Job),
  17.     Terminate,
  18. }
  20. impl ThreadPool {
  21.     /// 创建线程池。
  22.     ///
  23.     /// 线程池中线程的数量。
  24.     ///
  25.     /// # Panics
  26.     ///
  27.     /// `new` 函数在 size 为 0 时会 panic。
  28.     pub fn new(size: usize) -> ThreadPool {
  29.         assert!(size > 0);
  31.         let (sender, receiver) = mpsc::channel();
  32.         //Arc 多线程安全的智能指针
  33.         let receiver = Arc::new(Mutex::new(receiver));
  35.         let mut workers = Vec::with_capacity(size);
  37.         for id in 0..size {
  38.             workers.push(Worker::new(id, Arc::clone(&receiver)));
  39.         }
  41.         ThreadPool { workers, sender }
  42.     }
  44.     pub fn execute<F>(&self, f: F)
  45.     where
  46.         F: FnOnce() + Send + 'static,
  47.     {
  48.         let job = Box::new(f);
  50.         self.sender.send(Message::NewJob(job)).unwrap();
  51.     }
  52. }
  54. // 为 ThreadPool 实现 Drop Trait
  55. impl Drop for ThreadPool {
  56.     fn drop(&mut self) {
  57.         println!("Sending terminate message to all workers.");
  59.         for _ in &mut self.workers {
  60.             self.sender.send(Message::Terminate).unwrap();
  61.         }
  63.         for worker in &mut self.workers {
  64.             println!("Shutting down worker {}", worker.id);
  66.             if let Some(thread) = worker.thread.take() {
  67.                 thread.join().unwrap();
  68.             }
  69.         }
  70.     }
  71. }
  72. // 如果 Worker 存放的是 Option<thread::JoinHandle<()>，就可以在 Option 上调用 take 方法将值
  73. //从 Some 成员中移动出来
  74. //而对 None 成员不做处理。换句话说，正在运行的 Worker 的 thread 将是 Some 成员值，
  75. //而当需要清理 worker 时，将 Some 替换为 None，这样 worker 就没有可以运行的线程了
  76. struct Worker {
  77.     id: usize,
  78.     thread: Option<thread::JoinHandle<()>>,
  79. }
  81. impl Worker {
  82.     fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
  83.         let thread = thread::spawn(move || loop {
  84.             let message = receiver.lock().unwrap().recv().unwrap();
  86.             match message {
  87.                 Message::NewJob(job) => {
  88.                     println!("Worker {} got a job; executing.", id);
  90.                     job();
  91.                 }
  92.                 Message::Terminate => {
  93.                     println!("Worker {} was told to terminate.", id);
  95.                     break;
  96.                 }
  97.             }
  98.         });
  100.         Worker {
  101.             id,
  102.             thread: Some(thread),
  103.         }
  104.     }
  105. }
复制代码
src/bin/main.rs
  1. use std::{
  2.     sync::{mpsc, Arc, Mutex},
  3.     thread,
  4. };
  6. pub struct ThreadPool {
  7.     workers: Vec<Worker>,
  8.     sender: mpsc::Sender<Message>,
  9. }
  10. // 持有发送到channal的闭包
  11. // Job是某个特征对象的类型别名
  12. type Job = Box<dyn FnOnce() + Send + 'static>;
  14. // 向线程发送信号使其停止接收任务
  15. enum Message {
  16.     NewJob(Job),
  17.     Terminate,
  18. }
  20. impl ThreadPool {
  21.     /// 创建线程池。
  22.     ///
  23.     /// 线程池中线程的数量。
  24.     ///
  25.     /// # Panics
  26.     ///
  27.     /// `new` 函数在 size 为 0 时会 panic。
  28.     pub fn new(size: usize) -> ThreadPool {
  29.         assert!(size > 0);
  31.         let (sender, receiver) = mpsc::channel();
  32.         //Arc 多线程安全的智能指针
  33.         let receiver = Arc::new(Mutex::new(receiver));
  35.         let mut workers = Vec::with_capacity(size);
  37.         for id in 0..size {
  38.             workers.push(Worker::new(id, Arc::clone(&receiver)));
  39.         }
  41.         ThreadPool { workers, sender }
  42.     }
  44.     pub fn execute<F>(&self, f: F)
  45.     where
  46.         F: FnOnce() + Send + 'static,
  47.     {
  48.         let job = Box::new(f);
  50.         self.sender.send(Message::NewJob(job)).unwrap();
  51.     }
  52. }
  54. // 为 ThreadPool 实现 Drop Trait
  55. impl Drop for ThreadPool {
  56.     fn drop(&mut self) {
  57.         println!("Sending terminate message to all workers.");
  59.         for _ in &mut self.workers {
  60.             self.sender.send(Message::Terminate).unwrap();
  61.         }
  63.         for worker in &mut self.workers {
  64.             println!("Shutting down worker {}", worker.id);
  66.             if let Some(thread) = worker.thread.take() {
  67.                 thread.join().unwrap();
  68.             }
  69.         }
  70.     }
  71. }
  72. // 如果 Worker 存放的是 Option<thread::JoinHandle<()>，就可以在 Option 上调用 take 方法将值
  73. //从 Some 成员中移动出来
  74. //而对 None 成员不做处理。换句话说，正在运行的 Worker 的 thread 将是 Some 成员值，
  75. //而当需要清理 worker 时，将 Some 替换为 None，这样 worker 就没有可以运行的线程了
  76. struct Worker {
  77.     id: usize,
  78.     thread: Option<thread::JoinHandle<()>>,
  79. }
  81. impl Worker {
  82.     fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Message>>>) -> Worker {
  83.         let thread = thread::spawn(move || loop {
  84.             let message = receiver.lock().unwrap().recv().unwrap();
  86.             match message {
  87.                 Message::NewJob(job) => {
  88.                     println!("Worker {} got a job; executing.", id);
  90.                     job();
  91.                 }
  92.                 Message::Terminate => {
  93.                     println!("Worker {} was told to terminate.", id);
  95.                     break;
  96.                 }
  97.             }
  98.         });
  100.         Worker {
  101.             id,
  102.             thread: Some(thread),
  103.         }
  104.     }
  105. }
复制代码
参考



  • 第20章～构建单线程服务器
  • 构建单线程 Web 服务器

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

农民

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

集成商 AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表