RustでRESTサービスを作成します。 パート5：ハンドラー、リファクタリング、およびマクロ

Arcを2回クローン化した理由

let sdb = Arc::new(Mutex::new(db)); let mut router = router::Router::new(); { let sdb_ = sdb.clone(); router.get("/api/v1/records", move |req: &mut Request| handlers::get_records(sdb_.clone(), req)); } { let sdb_ = sdb.clone(); router.get("/api/v1/records/:id", move |req: &mut Request| handlers::get_record(sdb_.clone(), req)); } … 

 pub fn get_records(sdb: Arc<Mutex<Connection>>, req: &mut Request) -> IronResult<Response> { let url = req.url.clone().into_generic_url(); let mut name: Option<String> = None; if let Some(qp) = url.query_pairs() { for (key, value) in qp { match (&key[..], value) { ("name", n) => { if let None = name { name = Some(n); } else { return Ok(Response::with((status::BadRequest, "passed name in query more than once"))); } } _ => return Ok(Response::with((status::BadRequest, "unexpected query parameters"))), } } } else { return Ok(Response::with((status::BadRequest, "passed names don't parse as application/x-www-form-urlencoded or there are no parameters"))); } let json_records; if let Ok(recs) = ::db::read(sdb, name.as_ref().map(|s| &s[..])) { use rustc_serialize::json; if let Ok(json) = json::encode(&recs) { json_records = Some(json); } else { return Ok(Response::with((status::InternalServerError, "couldn't convert records to JSON"))); } } else { return Ok(Response::with((status::InternalServerError, "couldn't read records from database"))); } let content_type = Mime( TopLevel::Application, SubLevel::Json, Vec::new()); Ok(Response::with( (content_type, status::Ok, json_records.unwrap()))) } 

 pub fn get_records(sdb: Arc<Mutex<Connection>>, req: &mut Request) -> IronResult<Response> { 

ハンドラーで何が起こるか

  let url = req.url.clone().into_generic_url(); 

させて

  if let Some(qp) = url.query_pairs() { for (key, value) in qp { 

無効なHTTPステータスを返す

  } else { return Ok(Response::with((status::BadRequest, “passed names don't parse as application/x-www-form-urlencoded or there are no parameters”))); } 

リクエストパラメーターを取得する

  let mut name: Option<String> = None; if let Some(qp) = url.query_pairs() { for (key, value) in qp { match (&key[..], value) { ("name", n) => { if let None = name { name = Some(n); } else { return Ok(Response::with((status::BadRequest, "passed name in query more than once"))); } } _ => return Ok(Response::with((status::BadRequest, "unexpected query parameters"))), } } } 

パラメーターによってサイクルを削除します

  let mut name: Option<String> = None; if let Some(mut qp) = url.query_pairs() { if qp.len() != 1 { return Ok(Response::with((status::BadRequest, "passed more than one parameter or no parameters at all"))); } let (key, value) = qp.pop().unwrap(); if key == "name" { name = Some(value); } } else { 

  let (key, value) = qp.pop().unwrap(); 

文字列比較が＆strで機能するのはなぜですか？

  if key == "name" { name = Some(value); } 

 impl<'a> PartialEq<&'a str> for String 

初期化されていない変数-危険ですか？

  let json_records; 

 fn main() { let a; if true { a = 5; } else { println!("{}", a); } } 

 test.rs:6:24: 6:25 error: use of possibly uninitialized variable: `a` [E0381] test.rs:6 println!("{}", a); ^ 

データベースからレコードを読み取ります。 Option :: mapを使用します

  if let Ok(recs) = ::db::read(sdb, name.as_ref().map(|s| &s[..])) { 

  name.as_ref().map(|s| &s[..]) 

 pub fn read(sdb: Arc<Mutex<Connection>>, name: Option<&str>) -> Result<Vec<Record>, ()> { 

  .map(|s| &s[..]) 

 handlers.rs:25:53：25:54エラー： `s`は十分な長さではありません
 handlers.rs:25 if Ok（recs）= :: db :: read（sdb、name.map（| s |＆s [..]））{
                                                                    ^
 handlers.rs:25:23：25:60注：参照は25:22の呼び出しに対して有効でなければなりません...
 handlers.rs:25 if Ok（recs）= :: db :: read（sdb、name.map（| s |＆s [..]））{
                                      ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 handlers.rs:25:52：25:58注：...ただし、借用した値は25:51の関数のパラメーターのスコープでのみ有効です
 handlers.rs:25 if Ok（recs）= :: db :: read（sdb、name.map（| s |＆s [..]））{
                                                                   ^ ~~~~~ 

しかし、マルチスレッドについてはどうでしょうか？

  if let Ok(rs) = show(&*sdb.lock().unwrap(), name) { Ok(rs) } else { Err(()) } 

 pub fn show(db: &Connection, arg: Option<&str>) -> ::postgres::Result<Vec<Record>> { 

ほとんど魔法

 impl<T> Deref for Arc<T> where T: ?Sized type Target = T fn deref(&self) -> &T 

 struct Foo; impl Foo { fn foo(&self) { println!("Foo"); } } let f = Foo; f.foo(); (&f).foo(); (&&f).foo(); (&&&&&&&&f).foo(); 

RAIIを使用したミューテックスセーフリリース

連載

  use rustc_serialize::json; 

  if let Ok(json) = json::encode(&recs) { json_records = Some(json); } ... 

 #[derive(RustcEncodable, RustcDecodable)] pub struct Record { id: Option<i32>, pub name: String, pub phone: String, } 

すべてを送り返します

  let content_type = Mime( TopLevel::Application, SubLevel::Json, Vec::new()); Ok(Response::with( (content_type, status::Ok, json_records.unwrap()))) 

クローンをクローンしません

  { let sdb_ = sdb.clone(); router.get("/api/v1/records", move |req: &mut Request| handlers::get_records(sdb_.clone(), req)); } 

 pub fn get_records(sdb: Arc<Mutex<Connection>>, req: &mut Request) -> IronResult<Response> { 

 pub fn get_records(sdb: &Mutex<Connection>, req: &mut Request) -> IronResult<Response> { 

  { let sdb = sdb.clone(); router.get("/api/v1/records", move |req: &mut Request| handlers::get_records(&*sdb, req)); } 

 fn main() { let (params, sslmode) = params(); let db = Connection::connect(params, &sslmode).unwrap(); init_db(&db); let args: Vec<String> = std::env::args().collect(); match args.get(1) { Some(text) => { match text.as_ref() { "add" => add(&db, &args), "del" => del(&db, &args), "edit" => edit(&db, &args), "show" => show(&db, &args), "help" => println!("{}", HELP), "serve" => serve(db), command => panic!( format!("Invalid command: {}", command)) } } None => panic!("No command supplied"), } } 

rustfmt！

 $ rustfmt src / main.rs 

マクロ

  { let sdb = sdb.clone(); router.get("/api/v1/records", move |req: &mut Request| handlers::get_records(&*sdb, req)); } { let sdb = sdb.clone(); router.get("/api/v1/records/:id", move |req: &mut Request| handlers::get_record(&*sdb, req)); } { let sdb = sdb.clone(); router.post("/api/v1/records", move |req: &mut Request| handlers::add_record(&*sdb, req)); } { let sdb = sdb.clone(); router.put("/api/v1/records/:id", move |req: &mut Request| handlers::update_record(&*sdb, req)); } { let sdb = sdb.clone(); router.delete("/api/v1/records/:id", move |req: &mut Request| handlers::delete_record(&*sdb, req)); } 

 macro_rules! clone_pass_bound { ($arc:ident, $stmt:stmt) => { { let $arc = $arc.clone(); $stmt; } } } 

  clone_pass_bound!( sdb, router.get("/api/v1/records", move |req: &mut Request| handlers::get_records(&*sdb, req))); 

マクロ上のマクロ

 macro_rules! define_handler { ($connection:ident, $router: ident.$method:ident, $route:expr, $handler:path) => { clone_pass_bound!( $connection, $router.$method( $route, move |req: &mut Request| $handler(&*$connection, req))); } } 

  define_handler!(sdb, router.get, "/api/v1/records", handlers::get_records); define_handler!(sdb, router.get, "/api/v1/records/:id", handlers::get_record); define_handler!(sdb, router.post, "/api/v1/records", handlers::add_record); define_handler!(sdb, router.put, "/api/v1/records/:id", handlers::update_record); define_handler!(sdb, router.delete, "/api/v1/records/:id", handlers::delete_record); 

マクロドライブ

 macro_rules! define_handlers_family { ($connection:ident, $router:ident, $( [$method:ident, $route:expr, $handler:path]),+ ) => { $( define_handler!($connection, $router.$method, $route, $handler); )+ } } 

  ($connection:ident, $router:ident, $( [$method:ident, $route:expr, $handler:path]),+ ) => { 

  define_handler!($connection, $router.$method, $route, $handler); 

 main.rs:134:46: 134:53 error: variable 'method' is still repeating at this depth main.rs:134 define_handler!($connection, $router.$method, $route, $handler); ^~~~~~~ 

  $( define_handler!($connection, $router.$method, $route, $handler); )+ 

  define_handlers_family!( sdb, router, [get, "/api/v1/records", handlers::get_records], [get, "/api/v1/records/:id", handlers::get_record], [post, "/api/v1/records", handlers::add_record], [put, "/api/v1/records/:id", handlers::update_record], [delete, "/api/v1/records/:id", handlers::delete_record]); 

じゃあね！