अतुल्यकालिक आरंभिक React.js घटकों के सर्वर-साइड प्रतिपादन के लिए रणनीतियाँ


114

React.js के सबसे बड़े लाभों में से एक सर्वर-साइड रेंडरिंग माना जाता है । समस्या यह है कि कुंजी फ़ंक्शन React.renderComponentToString()सिंक्रोनस है जो किसी भी अतुल्यकालिक डेटा को लोड करना असंभव बनाता है क्योंकि घटक पदानुक्रम सर्वर पर प्रदान किया जाता है।

मान लें कि मेरे पास टिप्पणी करने के लिए एक सार्वभौमिक घटक है जिसे मैं पृष्ठ पर कहीं भी बहुत कम कर सकता हूं। इसके पास केवल एक संपत्ति है, कुछ प्रकार के पहचानकर्ता (उदाहरण के लिए एक लेख के नीचे आईडी जिसमें टिप्पणियाँ रखी गई हैं), और बाकी सब कुछ घटक द्वारा ही नियंत्रित किया जाता है (लोड करना, जोड़ना, प्रबंधित करना)।

मैं वास्तव में फ्लक्स आर्किटेक्चर को पसंद करता हूं क्योंकि यह बहुत सारी चीजों को आसान बनाता है, और इसके स्टोर सर्वर और क्लाइंट के बीच साझा करने के लिए एकदम सही हैं। एक बार जब मेरी स्टोर युक्त टिप्पणियों को इनिशियलाइज़ कर लिया जाता है, तो मैं इसे क्रमबद्ध कर सकता हूँ और इसे सर्वर से क्लाइंट पर भेज सकता हूँ जहाँ यह आसानी से बहाल हो जाता है।

सवाल यह है कि मेरे स्टोर को आबाद करने का सबसे अच्छा तरीका क्या है। पिछले दिनों के दौरान मैं बहुत कुछ कर रहा हूं और मैं कुछ रणनीतियों के साथ आया हूं, जिनमें से कोई भी वास्तव में अच्छा नहीं लग रहा था, यह देखते हुए कि रिएक्ट के इस फीचर को "बढ़ावा" दिया जा रहा है।

  1. मेरी राय में, सबसे आसान तरीका यह है कि वास्तविक रेंडरिंग शुरू होने से पहले मेरे सभी स्टोरों को आबाद कर दिया जाए। इसका मतलब है कि घटक पदानुक्रम के बाहर कहीं (उदाहरण के लिए मेरे राउटर को झुका हुआ)। इस दृष्टिकोण के साथ समस्या यह है कि मुझे पेज संरचना को दो बार बहुत अधिक परिभाषित करना होगा। अधिक जटिल पृष्ठ पर विचार करें, उदाहरण के लिए कई अलग-अलग घटकों (वास्तविक ब्लॉग पोस्ट, टिप्पणियां, संबंधित पोस्ट, नवीनतम पोस्ट, ट्विटर स्ट्रीम ...) के साथ एक ब्लॉग पेज। मुझे रिएक्ट घटकों का उपयोग करके पृष्ठ संरचना को डिज़ाइन करना होगा और फिर कहीं और मुझे इस वर्तमान पृष्ठ के लिए प्रत्येक आवश्यक स्टोर को आबाद करने की प्रक्रिया को परिभाषित करना होगा। यह मेरे लिए एक अच्छा समाधान की तरह प्रतीत नहीं होता है। दुर्भाग्य से अधिकांश आइसोमॉर्फिक ट्यूटोरियल इस तरह से डिज़ाइन किए गए हैं (उदाहरण के लिए यह महान फ्लक्स-ट्यूटोरियल )।

  2. प्रतिक्रिया-async । यह दृष्टिकोण एकदम सही है। यह मुझे प्रत्येक घटक में एक विशेष फ़ंक्शन में परिभाषित करता है कि कैसे राज्य को आरंभीकृत किया जाए (इससे कोई फर्क नहीं पड़ता कि क्या सिंक्रोनस या एसिंक्रोनस रूप से) और इन फ़ंक्शनों को HTML के लिए पदानुक्रम कहा जा रहा है। यह इस तरह से काम करता है कि एक घटक का प्रतिपादन तब तक नहीं किया जाता है जब तक कि राज्य पूरी तरह से प्रारंभिक नहीं हो जाता है। समस्या यह है कि इसके लिए फाइबर्स की आवश्यकता होती हैजो है, जहाँ तक मैं समझता हूँ, एक मानक मानक व्यवहार को बदलने वाला Node.js एक्सटेंशन। हालांकि मुझे वास्तव में परिणाम पसंद है, फिर भी यह मुझे लगता है कि समाधान खोजने के बजाय हमने खेल के नियमों को बदल दिया। और मुझे लगता है कि हमें React.js की इस मुख्य विशेषता का उपयोग करने के लिए मजबूर नहीं होना चाहिए। मैं इस समाधान के सामान्य समर्थन के बारे में भी निश्चित नहीं हूं। क्या मानक Node.js वेब होस्टिंग पर फाइबर का उपयोग करना संभव है?

  3. मैं अपने आप पर थोड़ा सोच रहा था। मैंने वास्तव में कार्यान्वयन विवरणों को गर्त में डालने के बारे में नहीं सोचा है, लेकिन सामान्य विचार यह है कि मैं घटकों को रिएक्ट-एसिंक्स के समान तरीके से विस्तारित करूंगा और फिर मैं रूट घटक पर बार-बार React.renderComponentToString () कॉल करूंगा। प्रत्येक पास के दौरान मैं फैली हुई कॉलबैक को इकट्ठा करूंगा और फिर दुकानों को आबाद करने के लिए और पास के कॉल पर उन्हें कॉल करूंगा। मैं इस चरण को तब तक दोहराता रहूंगा जब तक कि वर्तमान घटक पदानुक्रम द्वारा आवश्यक सभी स्टोर आबाद नहीं हो जाते। कई चीजों को हल किया जाना है और मैं प्रदर्शन के बारे में विशेष रूप से अनिश्चित हूं।

क्या मैं कुछ भुल गया? क्या एक और दृष्टिकोण / समाधान है? अभी मैं रिएक्ट-एसिंक्स / फाइबर्स तरीके से जाने के बारे में सोच रहा हूं, लेकिन मैं इसके बारे में पूरी तरह सुनिश्चित नहीं हूं, जैसा कि दूसरे बिंदु में बताया गया है।

GitHub पर संबंधित चर्चा । जाहिर है, कोई आधिकारिक दृष्टिकोण या समाधान भी नहीं है। शायद असली सवाल यह है कि रिएक्ट घटकों का उपयोग कैसे किया जाए। सरल दृश्य परत की तरह (बहुत अधिक मेरा सुझाव नंबर एक) या वास्तविक स्वतंत्र और स्टैंडअलोन घटकों की तरह?


बस चीजों को पाने के लिए: अतुल्यकालिक कॉल सर्वर-साइड पर भी होगा? मैं इस मामले में लाभों को समझ नहीं पाया क्योंकि कुछ हिस्सों को खाली छोड़ देने के साथ दृश्य प्रदान करने का विरोध किया, और इसे एसिंक्रोनस प्रतिक्रिया के परिणाम के रूप में भर दिया। शायद कुछ याद आ रहा है, क्षमा करें!
phtrivier

आपको यह नहीं भूलना चाहिए कि जावास्क्रिप्ट में भी नवीनतम पोस्ट लाने के लिए डेटाबेस की सबसे सरल क्वेरी अतुल्यकालिक है। इसलिए यदि आप एक दृश्य प्रस्तुत कर रहे हैं, तो आपको तब तक इंतजार करना होगा जब तक कि डेटाबेस से डेटा प्राप्त न हो जाए। और सर्वर-साइड पर प्रतिपादन के स्पष्ट लाभ हैं: उदाहरण के लिए एसईओ। और यह पेज को टिमटिमाने से भी रोकता है। वास्तव में सर्वर-साइड रेंडरिंग मानक दृष्टिकोण है जो अधिकांश वेबसाइट अभी भी उपयोग करते हैं।
तोबिक

ज़रूर, लेकिन क्या आप पूरे पृष्ठ को रेंडर करने की कोशिश कर रहे हैं (एक बार सभी एसिंक्रोनस डीबी प्रश्नों का जवाब दिया है)? जिस स्थिति में, मैंने भोलेपन से इसे 1 के रूप में अलग किया होगा / सभी डेटा को अतुल्यकालिक रूप से 2 / जब प्राप्त किया हो, इसे "डंब" रिएक्ट व्यू में पास करें, और अनुरोध का जवाब दें। या क्या आप सर्वर-साइड रेंडरिंग करने की कोशिश कर रहे हैं, तो क्लाइंट-साइड एक ही कोड के साथ (और आपको रिएक्शन व्यू के करीब होने के लिए async कोड की आवश्यकता है?) क्षमा करें यदि वह मूर्खतापूर्ण लगता है, तो मुझे यकीन नहीं है कि मुझे मिल जाएगा आप क्या कर रहे हैं।
phtrivier

कोई समस्या नहीं, शायद अन्य लोगों को भी समझने की समस्या है :) आपने अभी जो वर्णन किया है वह समाधान नंबर दो है। लेकिन उदाहरण के लिए सवाल से टिप्पणी करने के लिए घटक ले लो। सामान्य क्लाइंट-साइड एप्लिकेशन में मैं उस घटक में सब कुछ कर सकता था (टिप्पणियों को लोड करना / जोड़ना)। घटक बाहरी दुनिया से अलग हो जाएगा और बाहरी दुनिया को इस घटक की परवाह नहीं करनी होगी। यह पूरी तरह से स्वतंत्र और स्टैंडअलोन होगा। लेकिन एक बार जब मैं सर्वर-साइड रेंडरिंग शुरू करना चाहता हूं, तो मुझे बाहर के अतुल्यकालिक सामान को संभालना होगा। और जो पूरे सिद्धांत को तोड़ता है।
टोबिक

बस स्पष्ट होने के लिए, मैं तंतुओं का उपयोग करने की वकालत नहीं कर रहा हूं, लेकिन बस सभी एसिंक्स कॉल कर रहे हैं , और वे सभी समाप्त होने के बाद (वादा या जो भी हो) का उपयोग करते हुए, सर्वर पक्ष पर घटक को प्रस्तुत करते हैं। (इसलिए प्रतिक्रिया घटकों को अतुल्यकालिक सामान के बारे में बिल्कुल भी नहीं पता होगा ।) अब, यह केवल एक राय है, लेकिन मैं वास्तव में रिएक्ट घटकों से सर्वर संचार से संबंधित कुछ भी पूरी तरह से हटाने के विचार को पसंद करता हूं (जो वास्तव में केवल दृश्य को प्रस्तुत करने के लिए यहां हैं। ।) और मुझे लगता है कि प्रतिक्रिया के पीछे दर्शन है, जो समझा सकता है कि आप जो कर रहे हैं वह थोड़ा जटिल है। वैसे भी, सौभाग्य :)
phtrivier

जवाबों:


15

यदि आप प्रतिक्रिया-राउटर का उपयोग करते हैं , तो आप बस willTransitionToघटकों में एक विधि को परिभाषित कर सकते हैं, जो एक Transitionऑब्जेक्ट को पास करता है जिसे आप कॉल कर सकते हैं .wait

इससे कोई फर्क नहीं पड़ता कि रेंडरटॉस्ट्रिंग समकालिक है क्योंकि कॉलबैक को Router.runतब तक नहीं बुलाया जाएगा जब तक कि सभी .waitएड वादों को हल नहीं किया जाता है , इसलिए जब तक renderToStringकि मिडलवेयर में कहा जाता है आप स्टोरों को आबाद कर सकते थे। यहां तक ​​कि अगर स्टोर एकल हैं तो आप सिंक्रोनाइज़िंग कॉल से पहले अपना डेटा अस्थायी रूप से सिर्फ-इन-टाइम सेट कर सकते हैं और घटक इसे देखेगा।

मिडलवेयर का उदाहरण:

var Router = require('react-router');
var React = require("react");
var url = require("fast-url-parser");

module.exports = function(routes) {
    return function(req, res, next) {
        var path = url.parse(req.url).pathname;
        if (/^\/?api/i.test(path)) {
            return next();
        }
        Router.run(routes, path, function(Handler, state) {
            var markup = React.renderToString(<Handler routerState={state} />);
            var locals = {markup: markup};
            res.render("layouts/main", locals);
        });
    };
};

routesवस्तु (जो मार्गों पदानुक्रम का वर्णन करता है) क्लाइंट और सर्वर के साथ साझा किया जाता है शब्दशः


धन्यवाद। बात यह है कि जहां तक ​​मुझे पता है, केवल मार्ग घटक इस willTransitionToपद्धति का समर्थन करते हैं । जिसका अर्थ है कि प्रश्न में वर्णित एक की तरह पूरी तरह से स्टैंडअलोन पुन: प्रयोज्य घटकों को लिखना अभी भी संभव नहीं है। लेकिन जब तक हम फाइबर्स के साथ जाने के लिए तैयार नहीं होते हैं, यह संभवतः सर्वर-साइड रेंडरिंग को लागू करने का सबसे अच्छा और सबसे प्रतिक्रिया तरीका है।
टोबिक डे

यह दिलचस्प है। विल ट्रांसट्रांसटाउन पद्धति का क्रियान्वयन कैसे होगा कि एसिंक्स डेटा लोड किया जाए?
Hyra

आपको transitionऑब्जेक्ट एक पैरामीटर के रूप में मिलेगा , इसलिए आप बस कॉल करेंगे transition.wait(yourPromise)। बेशक इसका मतलब है कि आपको वादों का समर्थन करने के लिए अपने एपीआई को लागू करना होगा। इस दृष्टिकोण का एक और नुकसान यह है कि क्लाइंट साइड पर "लोडिंग इंडिकेटर" को लागू करने का कोई सरल तरीका नहीं है। जब तक सभी वादों का समाधान नहीं हो जाता, तब तक मार्ग मार्ग संचालक के पास नहीं जाएगा।
तोबीक

लेकिन मैं वास्तव में "जस्ट-इन-टाइम" दृष्टिकोण के बारे में निश्चित नहीं हूं। एकाधिक नेस्टेड मार्ग हैंडलर एक यूआरएल से मेल कर सकते हैं जिसका अर्थ है कि कई वादों को हल करना होगा। कोई गारंटी नहीं है कि वे एक ही समय में समाप्त हो जाएंगे। यदि स्टोर एकल हैं, तो यह संघर्ष का कारण बन सकता है। @Esailija शायद आप अपना जवाब थोड़ा समझा सकते हैं?
तोबिक

मेरे पास स्वचालित प्लंबिंग है जो .waitedएक संक्रमण के लिए सभी वादों को एकत्र करता है । एक बार जब वे सभी पूरे हो जाते हैं, तो .runकॉलबैक कहा जाता है। इससे पहले कि .render()मैं सभी डेटा एक साथ वादों से इकट्ठा करता हूं और सिंगलटन स्टोर स्टेट्स सेट करता हूं, फिर रेंडर कॉल के बाद अगली लाइन पर मैं सिंगलटन स्टोर्स को वापस शुरू करता हूं। यह बहुत हैक है, लेकिन यह सब स्वचालित रूप से होता है और घटक और स्टोर एप्लिकेशन कोड लगभग समान रहता है।
एस्लेलिजा

0

मुझे पता है कि यह संभवतः वह नहीं है जो आप चाहते हैं, और यह समझ में नहीं आ सकता है, लेकिन मुझे याद है कि दोनों को संभालने के लिए घटक को धीरे से संशोधित करके:

  • सर्वर की तरफ से प्रस्तुत करना, पहले से ही प्राप्त सभी प्रारंभिक अवस्था के साथ, अतुल्यकालिक रूप से यदि आवश्यक हो)
  • यदि आवश्यक हो तो ग्राहक पक्ष पर प्रतिपादन, AJAX के साथ

तो कुछ इस तरह:

/** @jsx React.DOM */

var UserGist = React.createClass({
  getInitialState: function() {

    if (this.props.serverSide) {
       return this.props.initialState;
    } else {
      return {
        username: '',
        lastGistUrl: ''
      };
    }

  },

  componentDidMount: function() {
    if (!this.props.serverSide) {

     $.get(this.props.source, function(result) {
      var lastGist = result[0];
      if (this.isMounted()) {
        this.setState({
          username: lastGist.owner.login,
          lastGistUrl: lastGist.html_url
        });
      }
    }.bind(this));

    }

  },

  render: function() {
    return (
      <div>
        {this.state.username}'s last gist is
        <a href={this.state.lastGistUrl}>here</a>.
      </div>
    );
  }
});

// On the client side
React.renderComponent(
  <UserGist source="https://api.github.com/users/octocat/gists" />,
  mountNode
);

// On the server side
getTheInitialState().then(function (initialState) {

    var renderingOptions = {
        initialState : initialState;
        serverSide : true;
    };
    var str = Xxx.renderComponentAsString( ... renderingOptions ...)  

});

मुझे खेद है कि मेरे पास सटीक कोड नहीं है, इसलिए यह बॉक्स से बाहर काम नहीं कर सकता है, लेकिन मैं चर्चा के हित में पोस्ट कर रहा हूं।

फिर, विचार यह है कि अधिकांश घटक को एक मूक दृश्य के रूप में माना जाए, और घटक से जितना संभव हो उतना डेटा प्राप्त करने के लिए सौदा किया जाए ।


1
धन्यवाद। मुझे विचार मिलता है, लेकिन यह वास्तव में वह नहीं है जो मैं चाहता हूं। मान लीजिए कि मैं रिएक्ट का उपयोग करके कुछ और जटिल वेबसाइट बनाना चाहता हूं, जैसे bbc.com । पृष्ठ को देखते हुए, मैं हर जगह "घटक" देख सकता हूं। एक खंड (खेल, व्यवसाय ...) एक विशिष्ट घटक है। आप इसे कैसे लागू करेंगे? आप सभी डेटा को कहां से प्रीफ़ैच करेंगे? इस तरह के एक जटिल साइट को डिजाइन करने के लिए, घटक (एक सिद्धांत के रूप में, छोटे एमवीसी कंटेनर की तरह) बहुत अच्छे हैं (यदि हो सकता है) केवल जाने का रास्ता। घटक दृष्टिकोण कई विशिष्ट सर्वर-साइड चौखटे के लिए आम है। सवाल यह है कि क्या मैं इसके लिए रिएक्ट का उपयोग कर सकता हूं?
टोबिक

आप सर्वर-साइड पर डेटा को प्रीफ़ैच करेंगे (जैसा कि संभवतः यह इस मामले में किया गया है, इसे "पारंपरिक" सर्वर-साइड टेम्पलेट सिस्टम में पास करने से पहले); सिर्फ इसलिए कि डेटा के प्रदर्शन को मॉड्यूलर होने से लाभ मिलता है, क्या इसका मतलब है कि डेटा प्रॉपरली की गणना समान संरचना का पालन करना है? मैं यहाँ शैतान के वकील की भूमिका निभा रहा हूँ, मुझे वही परेशानी हुई जब आप ओम की जाँच कर रहे थे। और मुझे यकीन है कि किसी को इस पर अधिक अंतर्दृष्टि है तो मैं करता हूं - मूल रूप से तार के किसी भी तरफ सामान रचना बहुत मदद करेगा।
phtrivier

1
कोड में मेरा मतलब कहां है। कंट्रोलर में? तो बीबीसी के होम पेज को संभालने वाली कंट्रोलर विधि में प्रत्येक सेक्शन के लिए एक जैसे दर्जनों प्रश्न होंगे? यह एक तरह से नरक है। तो हाँ, मैं ऐसा लगता है कि गणना के साथ-साथ मॉड्यूलर होना चाहिए। सब कुछ एक घटक में पैक किया गया, एक एमवीसी कंटेनर में। यही कारण है कि मैं मानक सर्वर-साइड ऐप विकसित करता हूं और मुझे पूरा विश्वास है कि यह दृष्टिकोण अच्छा है। और यही वजह है कि मैं React.js के बारे में इतना उत्साहित हूं कि भयानक आइसोमॉर्फिक ऐप बनाने के लिए क्लाइंट और सर्वर दोनों तरफ इस दृष्टिकोण का उपयोग करने की बहुत संभावना है।
तोबिक

1
किसी भी साइट (बड़े / छोटे) पर, आपको केवल सर्वर-साइड रेंडर (SSR) चालू पृष्ठ को अपनी init स्थिति के साथ रखना होगा; आपको प्रत्येक पृष्ठ के लिए init राज्य की आवश्यकता नहीं है। सर्वर init स्थिति पकड़ लेता है, इसे रेंडर करता है, और इसे क्लाइंट को पास करता है <script type=application/json>{initState}</script>; इस तरह से डेटा HTML में होगा। क्लाइंट पर रेंडर कॉल करके यूआई घटनाओं को पेज पर रीहाइड्रेट / बाइंड करें। इसके बाद के पेज क्लाइंट के जेएस कोड (जरूरत के मुताबिक डेटा लाने) और क्लाइंट द्वारा रेंडर किए जाते हैं। इस तरह से कोई भी ताज़ा ताज़ा SSR पृष्ठ लोड हो जाएगा और एक पृष्ठ पर क्लिक करना CSR होगा। = आइसोमॉर्फिक और एसईओ अनुकूल
फेडेरिको

0

मैं आज वास्तव में इसके साथ खिलवाड़ कर रहा था, और यद्यपि यह आपकी समस्या का जवाब नहीं है, फिर भी मैंने इस दृष्टिकोण का उपयोग किया है। मैं प्रतिक्रिया रूटर के बजाय रूटिंग के लिए एक्सप्रेस का उपयोग करना चाहता था, और मैं फाइबर का उपयोग नहीं करना चाहता था क्योंकि मुझे नोड में थ्रेडिंग समर्थन की आवश्यकता नहीं थी।

इसलिए मैंने सिर्फ एक निर्णय लिया कि प्रारंभिक डेटा के लिए जिसे लोड पर फ्लक्स स्टोर तक पहुंचाने की आवश्यकता है, मैं एक AJAX अनुरोध करूंगा और स्टोर में प्रारंभिक डेटा पास करूंगा

मैं इस उदाहरण के लिए Fluxxor का उपयोग कर रहा था।

तो मेरे एक्सप्रेस रूट पर, इस मामले में एक /productsरूट:

var request = require('superagent');
var url = 'http://myendpoint/api/product?category=FI';

request
  .get(url)
  .end(function(err, response){
    if (response.ok) {    
      render(res, response.body);        
    } else {
      render(res, 'error getting initial product data');
    }
 }.bind(this));

फिर मेरी इनिशियलाइज़ रेंडर विधि जो डेटा को स्टोर में पास करती है।

var render = function (res, products) {
  var stores = { 
    productStore: new productStore({category: category, products: products }),
    categoryStore: new categoryStore()
  };

  var actions = { 
    productActions: productActions,
    categoryActions: categoryActions
  };

  var flux = new Fluxxor.Flux(stores, actions);

  var App = React.createClass({
    render: function() {
      return (
          <Product flux={flux} />
      );
    }
  });

  var ProductApp = React.createFactory(App);
  var html = React.renderToString(ProductApp());
  // using ejs for templating here, could use something else
  res.render('product-view.ejs', { app: html });

0

मुझे पता है कि यह सवाल एक साल पहले पूछा गया था, लेकिन हमारे पास एक ही समस्या थी और हम इसे उन निहित वादों के साथ हल करते हैं जो घटकों से प्राप्त किए गए थे जो रेंडर होने जा रहे हैं। अंत में हमारे पास ऐप के लिए सभी डेटा थे और बस इसे नीचे भेज दिया।

उदाहरण के लिए:

var App = React.createClass({

    /**
     *
     */
    statics: {
        /**
         *
         * @returns {*}
         */
        getData: function (t, user) {

            return Q.all([

                Feed.getData(t),

                Header.getData(user),

                Footer.getData()

            ]).spread(
                /**
                 *
                 * @param feedData
                 * @param headerData
                 * @param footerData
                 */
                function (feedData, headerData, footerData) {

                    return {
                        header: headerData,
                        feed: feedData,
                        footer: footerData
                    }

                });

        }
    },

    /**
     *
     * @returns {XML}
     */
    render: function () {

        return (
            <label>
                <Header data={this.props.header} />
                <Feed data={this.props.feed}/>
                <Footer data={this.props.footer} />
            </label>
        );

    }

});

और राउटर में

var AppFactory = React.createFactory(App);

App.getData(t, user).then(
    /**
     *
     * @param data
     */
    function (data) {

        var app = React.renderToString(
            AppFactory(data)
        );       

        res.render(
            'layout',
            {
                body: app,
                someData: JSON.stringify(data)                
            }
        );

    }
).fail(
    /**
     *
     * @param error
     */
    function (error) {
        next(error);
    }
);

0

आपके साथ सर्वर साइड रेंडरिंग के मेरे दृष्टिकोण को साझा करना चाहता हूं Flux, उदाहरण के लिए थोड़ा सरल किया जाए:

  1. मान लें कि हमारे पास componentस्टोर से प्रारंभिक डेटा है:

    class MyComponent extends Component {
      constructor(props) {
        super(props);
        this.state = {
          data: myStore.getData()
        };
      }
    }
  2. यदि प्रारंभिक अवस्था के लिए वर्ग को कुछ प्रीलोडेड डेटा की आवश्यकता होती है, तो इसके लिए लोडर बनाएं MyComponent:

     class MyComponentLoader {
        constructor() {
            myStore.addChangeListener(this.onFetch);
        }
        load() {
            return new Promise((resolve, reject) => {
                this.resolve = resolve;
                myActions.getInitialData(); 
            });
        }
        onFetch = () => this.resolve(data);
    }
  3. दुकान:

    class MyStore extends StoreBase {
        constructor() {
            switch(action => {
                case 'GET_INITIAL_DATA':
                this.yourFetchFunction()
                    .then(response => {
                        this.data = response;
                        this.emitChange();
                     });
                 break;
        }
        getData = () => this.data;
    }
  4. अब केवल राउटर में डेटा लोड करें:

    on('/my-route', async () => {
        await new MyComponentLoader().load();
        return <MyComponent/>;
    });

0

बस एक छोटे से रोलअप के रूप में -> ग्राफकॉइन आपके स्टैक के लिए इस को हल करेगा ...

  • GraphQL जोड़ें
  • अपोलो और प्रतिक्रिया-अपोलो का उपयोग करें
  • रेंडर करने से पहले "getDataFromTree" का उपयोग करें

-> getDataFromTree स्वचालित रूप से आपके ऐप में शामिल सभी प्रश्नों को ढूंढ लेगा और उन्हें निष्पादित करेगा, सर्वर पर आपके अपोलो कैश को पॉलेटिंग और इस प्रकार, पूरी तरह से काम कर रहे एसएसआर को सक्षम करेगा। BÄM

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.