Rust
आयरन वेब फ्रेमवर्क

परिचय

सरल 'हैलो' सर्वर

जब वे सर्वर अनुरोध भेजते हैं तो यह उदाहरण उपयोगकर्ता को एक हार्ड-कोडित प्रतिक्रिया भेजता है।

extern crate iron;

use iron::prelude::*;
use iron::status;

// You can pass the handler as a function or a closure. In this
// case, we've chosen a function for clarity.
// Since we don't care about the request, we bind it to _.
fn handler(_: &mut Request) -> IronResult<Response> {
    Ok(Response::with((status::Ok, "Hello, Stack Overflow")))
}

fn main() {
    Iron::new(handler).http("localhost:1337").expect("Server failed!")
}

इस उदाहरण में एक नया Iron सर्वर बनाते समय, अधिक वर्णनात्मक त्रुटि संदेश के साथ किसी भी त्रुटि को पकड़ने की expect करें। उत्पादन अनुप्रयोगों में, उत्पादित त्रुटि को संभालना ( http() लिए प्रलेखन देखें)।

लोहा स्थापित करना

इस निर्भरता को Cargo.toml फाइल में जोड़ें:

[dependencies]
iron = "0.4.0"

रन cargo build और कार्गो आयरन के निर्दिष्ट संस्करण को डाउनलोड और इंस्टॉल करेंगे।

लोहे के साथ सरल अनुमार्गण

यह उदाहरण आयरन का उपयोग करके बुनियादी वेब रूटिंग प्रदान करेगा।

इसके साथ शुरू करने के लिए, आपको अपनी Cargo.toml फ़ाइल में आयरन निर्भरता को जोड़ना होगा।

[dependencies]
iron = "0.4.*"

हम आयरन की अपनी राउटर लाइब्रेरी का उपयोग करेंगे। सरलता के लिए, आयरन प्रोजेक्ट इस लाइब्रेरी को आयरन कोर लाइब्रेरी के हिस्से के रूप में प्रदान करता है, जो इसे एक अलग निर्भरता के रूप में जोड़ने की आवश्यकता को हटा देता है। आगे हम आयरन लाइब्रेरी और राउटर लाइब्रेरी दोनों का संदर्भ देते हैं।

extern crate iron;
extern crate router;

फिर हम रूटिंग को प्रबंधित करने में सक्षम करने के लिए आवश्यक वस्तुओं को आयात करते हैं, और उपयोगकर्ता को एक प्रतिक्रिया लौटाते हैं।

use iron::{Iron, Request, Response, IronResult};
use iron::status;
use router::{Router};

इस उदाहरण में, हम अपने main() फ़ंक्शन के भीतर रूटिंग लॉजिक लिखकर इसे सरल रखेंगे। बेशक, जैसे ही आपका एप्लिकेशन बढ़ता है, आप रूटिंग, लॉगिंग, सुरक्षा चिंताओं और अपने वेब एप्लिकेशन के अन्य क्षेत्रों को अलग करना चाहेंगे। अभी के लिए, यह एक अच्छा शुरुआती बिंदु है।

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "handler");
    router.get("/:query", query_handler, "query_handler");

अब तक जो भी हमने हासिल किया है, उस पर चलते हैं। वर्तमान में हमारा कार्यक्रम एक नए आयरन Router ऑब्जेक्ट को तत्काल चालू करता है, और दो "हैंडलर" को दो प्रकार के URL अनुरोधों से जोड़ देता है: पहला ( "/" ) हमारे डोमेन का मूल है, और दूसरा ( "/:query" ) कोई भी मार्ग है जड़ के नीचे।

"क्वेरी" शब्द से पहले एक अर्ध-उपनिवेश का उपयोग करके, हम आयरन को URL पथ के इस हिस्से को एक चर के रूप में लेने और इसे हमारे हैंडलर में पास करने के लिए कह रहे हैं।

कोड की अगली पंक्ति यह है कि हम अपने URL अनुरोधों को प्रबंधित करने के लिए अपने स्वयं के router ऑब्जेक्ट को कैसे नामित करते हैं, आइरन को कैसे इंस्टेंट करते हैं। सादगी के लिए इस उदाहरण में डोमेन और पोर्ट हार्ड-कोडेड हैं।

    Iron::new(router).http("localhost:3000").unwrap();

अगला, हम दो इनलाइन फ़ंक्शन घोषित करते हैं जो हमारे हैंडलर, handler और query_handler । ये दोनों निश्चित URL और चर URL प्रदर्शित करने के लिए उपयोग किए जाते हैं।

दूसरे फ़ंक्शन में हम अनुरोध ऑब्जेक्ट द्वारा रखे गए URL से "query" चर लेते हैं, और हम इसे प्रतिक्रिया के रूप में उपयोगकर्ता को वापस भेजते हैं।

    fn handler(_: &mut Request) -> IronResult<Response> {
        Ok(Response::with((status::Ok, "OK")))
    }

    fn query_handler(req: &mut Request) -> IronResult<Response> {
        let ref query = req.extensions.get::<Router>()
            .unwrap().find("query").unwrap_or("/");
        Ok(Response::with((status::Ok, *query)))
    }
}

अगर हम इस उदाहरण को चलाते हैं, तो हम localhost:3000 ब्राउज़र में परिणाम को localhost:3000 पर देख पाएंगे। डोमेन के रूट को "OK" साथ जवाब देना चाहिए, और रूट के नीचे कुछ भी वापस पथ को दोहराना चाहिए।

इस उदाहरण से अगला चरण रूटिंग का पृथक्करण और स्थैतिक पृष्ठों की सेवा हो सकता है।