7

我正在尝试通过使用 Hyper 0.10 实现一个简单的内存 URL 缩短器来学习 Rust。我遇到了一个问题，我认为是由于尝试关闭HashMap处理程序中的可变对象引起的：

fn post(mut req: Request, mut res: Response, short_uris: &mut HashMap<&str, &str>) {
    let mut body = String::new();
    match req.read_to_string(&mut body) {
        Ok(_) => {
            let key = short_uris.len();
            short_uris.insert(&key.to_string(), &body.to_string());
            *res.status_mut() = StatusCode::Created;
            res.start().unwrap().write(&key.to_string().into_bytes());
        },
        Err(_) => *res.status_mut() = StatusCode::BadRequest
    }
}

fn get(req: Request, mut res: Response, short_uris: &HashMap<&str, &str>) {
    match req.uri.clone() {
        AbsolutePath(path) => {
            match short_uris.get::<str>(&path) {
                Some(short_uri) => {
                    *res.status_mut() = StatusCode::MovedPermanently;
                    res.headers_mut().set(Location(short_uri.to_string()));
                },
                None => *res.status_mut() = StatusCode::NotFound
            }
        },
        _ => *res.status_mut() = StatusCode::BadRequest
    }
}

fn main() {
    let mut short_uris: HashMap<&str, &str> = HashMap::new();
    short_uris.insert("/example", "http://www.example.com");
    Server::http("0.0.0.0:3001").unwrap().handle(move |req: Request, mut res: Response| {
        match req.method {
            hyper::Post => post(req, res, &mut short_uris),
            hyper::Get => get(req, res, &short_uris),
            _ => *res.status_mut() = StatusCode::MethodNotAllowed
        }
    }).unwrap();
}

src/main.rs:42:40: 42:46 error: the trait bound `for<'r, 'r, 'r> [closure@src/main.rs:42:47: 48:3 short_uris:std::collections::HashMap<&str, &str>]: std::ops::Fn<(hyper::server::Request<'r, 'r>, hyper::server::Response<'r>)>` is not satisfied [E0277]
src/main.rs:42  Server::http("0.0.0.0:3001").unwrap().handle(move |req: Request, mut res: Response| {

我是否需要使用一个Arc来共享HashMap线程之间？如果是这样，那会是什么样子？另外，我对这个问题可能完全错了。错误消息对我来说非常神秘。

4

1 回答 1

11

use下次请包括所有必要的声明，谢谢！

如果你使用的是夜间 Rust，错误消息就不那么神秘了：

期望一个实现该Fn特征的闭包，但这个闭包只实现FnMut

这意味着 Hyper 需要在线程之间共享闭包，因此闭包只需要通过不可变或共享方法来使用其环境——因此&mut short_uris这里的使用是违规者。要在 Rust 中提供共享的线程安全可变性，您应该使用Mutexor RwLock。

请注意，您在这里不需要- Hyper 管理闭包本身的所有权（可能Arc通过将闭包包装在Arc引擎盖下，或使用类似范围线程之类的东西）。

您的代码还有第二个问题 - 您使用HashMap<&str, &str>. &str是借来的参考。每次当你在 Rust 中借用一些东西时，你应该问问自己——从哪里借来的？在这里，您尝试从真正短暂的字符串中借用 -key.to_string()和body.to_string(). 它只是行不通。只需让您的 hashmap 完全拥有 – HashMap<String, String>. 这是编译的代码版本：

extern crate hyper;

use hyper::server::{Request, Response, Server};
use std::collections::HashMap;
use hyper::status::StatusCode;
use hyper::uri::RequestUri::AbsolutePath;
use hyper::header::Location;
use std::io::prelude::*;

fn post(mut req: Request, mut res: Response, short_uris: &mut HashMap<String, String>) {
    let mut body = String::new();
    match req.read_to_string(&mut body) {
        Ok(_) => {
            let key = short_uris.len();
            short_uris.insert(key.to_string(), body);
            *res.status_mut() = StatusCode::Created;
            res.start()
                .unwrap()
                .write(&key.to_string().into_bytes())
                .unwrap();
        }
        Err(_) => *res.status_mut() = StatusCode::BadRequest,
    }
}

fn get(req: Request, mut res: Response, short_uris: &HashMap<String, String>) {
    match req.uri {
        AbsolutePath(ref path) => match short_uris.get(path) {
            Some(short_uri) => {
                *res.status_mut() = StatusCode::MovedPermanently;
                res.headers_mut().set(Location(short_uri.to_string()));
            }
            None => *res.status_mut() = StatusCode::NotFound,
        },
        _ => *res.status_mut() = StatusCode::BadRequest,
    }
}

fn main() {
    let mut short_uris: HashMap<String, String> = HashMap::new();
    short_uris.insert("/example".into(), "http://www.example.com".into());
    let short_uris = std::sync::RwLock::new(short_uris);
    Server::http("0.0.0.0:3001")
        .unwrap()
        .handle(move |req: Request, mut res: Response| match req.method {
            hyper::Post => post(req, res, &mut short_uris.write().unwrap()),
            hyper::Get => get(req, res, &short_uris.read().unwrap()),
            _ => *res.status_mut() = StatusCode::MethodNotAllowed,
        })
        .unwrap();
}

我也摆脱了函数中不必要.clone()的东西。get

请注意，这段代码在编译时还不完美——RwLock锁应该持续更短（get并且post应该&RwLock<HashMap<String,String>>作为参数并自己执行锁定）。.unwrap()也可以以更好的方式处理。你也可以考虑使用一些无锁并发 hashmap，应该有一些 crates，但我不喜欢这个话题，所以我不会推荐任何东西。

于 2016-06-27T00:56:56.233 回答