手把手教你用 Rust 搭建 REST API

rustup default nightly

rustup override set nightly

[dependencies]rocket = "0.4.4"rocket_codegen = "0.4.4"diesel = { version = "1.4.0", features = ["postgres"] }dotenv = "0.9.0"r2d2-diesel = "1.0"r2d2 = "0.8"serde = "1.0"serde_derive = "1.0"serde_json = "1.0"custom_derive ="0.1.7"[dependencies.rocket_contrib]version = "*"default-features = falsefeatures = ["json"]

cargo install diesel_cli — no-default-features — features postgre

echo DATABASE_URL=postgres://username:password@localhost:port/diesel_demo > .env

diesel setup

= note: LINK : fatal error LNK1181: cannot open input file ‘libpq.lib’

setx PQ_LIB_DIR “[path to pg lib folder]”

diesel migration generate users

CREATE TABLE users(    id         SERIAL PRIMARY KEY,    username   VARCHAR NOT NULL,    password   VARCHAR NOT NULL,    first_name VARCHAR NOT NULL)

DROP TABLE users

diesel migration run

diesel migration redo

table! {    users (id) {        id -> Int4,        username -> Varchar,        password -> Varchar,        first_name -> Varchar,    }}

use diesel;use diesel::pg::PgConnection;use diesel::prelude::*;use super::schema::users;use super::schema::users::dsl::users as all_users;// this is to get users from the database#[derive(Serialize, Queryable)] pub struct User {    pub id: i32,    pub username: String,    pub password: String,    pub first_name: String,}

// decode request data#[derive(Deserialize)] pub struct UserData {    pub username: String,}// this is to insert users to database#[derive(Serialize, Deserialize, Insertable)]#[table_name = "users"]pub struct NewUser {    pub username: String,    pub password: String,    pub first_name: String,}

impl User {  pub fn get_all_users(conn: &PgConnection) -> Vec<User> {    all_users        .order(users::id.desc())        .load::<User>(conn)        .expect("error!")    }    pub fn insert_user(user: NewUser, conn: &PgConnection) -> bool {      diesel::insert_into(users::table)          .values(&user)          .execute(conn)          .is_ok()    }      pub fn get_user_by_username(user: UserData, conn: &PgConnection) -> Vec<User> {      all_users          .filter(users::username.eq(user.username))          .load::<User>(conn)          .expect("error!")    }}

use super::db::Conn as DbConn;use rocket_contrib::json::Json;use super::models::{User, NewUser};use serde_json::Value;use crate::models::UserData;
#[post("/users", format = "application/json")]pub fn get_all(conn: DbConn) -> Json<Value> {    let users = User::get_all_users(&conn);    Json(json!({        "status": 200,        "result": users,    }))}
#[post("/newUser", format = "application/json", data = "<new_user>")]pub fn new_user(conn: DbConn, new_user: Json<NewUser>) -> Json<Value> {    Json(json!({        "status": User::insert_user(new_user.into_inner(), &conn),        "result": User::get_all_users(&conn).first(),    }))}
#[post("/getUser", format = "application/json", data = "<user_data>")]pub fn find_user(conn: DbConn, user_data: Json<UserData>) -> Json<Value> {    Json(json!({        "status": 200,        "result": User::get_user_by_username(user_data.into_inner(), &conn),    }))}

use diesel::pg::PgConnection;use r2d2;use r2d2_diesel::ConnectionManager;use rocket::http::Status;use rocket::request::{self, FromRequest};use rocket::{Outcome, Request, State};use std::ops::Deref;
pub type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;
pub fn init_pool(db_url: String) -> Pool {    let manager = ConnectionManager::<PgConnection>::new(db_url);    r2d2::Pool::new(manager).expect("db pool failure")}
pub struct Conn(pub r2d2::PooledConnection<ConnectionManager<PgConnection>>);
impl<'a, 'r> FromRequest<'a, 'r> for Conn {    type Error = ();
    fn from_request(request: &'a Request<'r>) -> request::Outcome<Conn, ()> {        let pool = request.guard::<State<Pool>>()?;        match pool.get() {            Ok(conn) => Outcome::Success(Conn(conn)),            Err(_) => Outcome::Failure((Status::ServiceUnavailable, ())),        }    }}
impl Deref for Conn {    type Target = PgConnection;
    #[inline(always)]    fn deref(&self) -> &Self::Target {        &self.0    }}

#![feature(plugin, const_fn, decl_macro, proc_macro_hygiene)]#![allow(proc_macro_derive_resolution_fallback, unused_attributes)]#[macro_use]extern crate diesel;extern crate dotenv;extern crate r2d2;extern crate r2d2_diesel;#[macro_use]extern crate rocket;extern crate rocket_contrib;#[macro_use]extern crate serde_derive;#[macro_use]extern crate serde_json;use dotenv::dotenv;use std::env;use routes::*;use std::process::Command;mod db;mod models;mod routes;mod schema;fn rocket() -> rocket::Rocket {    dotenv().ok();    let database_url = env::var("DATABASE_URL").expect("set DATABASE_URL");    let pool = db::init_pool(database_url);    rocket::ignite()        .manage(pool)        .mount(            "/api/v1/",            routes![get_all, new_user, find_user],        )}fn main() {    let _output = if cfg!(target_os = "windows") {        Command::new("cmd")            .args(&["/C", "cd ui && npm start"])            .spawn()            .expect("Failed to start UI Application")    } else {        Command::new("sh")            .arg("-c")            .arg("cd ui && npm start")            .spawn()            .expect("Failed to start UI Application")    };    rocket().launch();}