क्या एंगुलरजेएस ऑटो व्यू को तब अपडेट कर सकता है जब एक बाहरी मॉडल (सर्वर डेटाबेस) किसी बाहरी ऐप द्वारा बदला जाता है?

Question 1

मैं केवल AngularJS से परिचित होना शुरू कर रहा हूं, लेकिन मैं एक वेब ऐप बनाना चाहूंगा, जिसमें एक ऐसा दृश्य हो, जो सर्वर-साइड डेटाबेस में कुछ परिवर्तन होने पर उपयोगकर्ता के लिए वास्तविक समय (बिना रिफ्रेश) में ऑटो-अप हो जाए।

क्या AngularJS मेरे लिए यह (अधिकतर) स्वचालित रूप से संभाल सकता है? और यदि हां, तो काम पर बुनियादी तंत्र क्या है?

उदाहरण के लिए, क्या आप किसी तरह "मॉडल" परिवर्तनों के लिए नियमित रूप से DB को चुनने के लिए AngularJS सेटअप करते हैं? या AngularJS क्लाइंट-साइड कोड को सूचित करने के लिए कुछ प्रकार के धूमकेतु जैसे तंत्र का उपयोग करें कि मॉडल बदल गया है?

मेरे आवेदन में, चुनौती यह है कि अन्य (गैर-वेब) सर्वर-साइड सॉफ़्टवेयर कई बार डेटाबेस को अपडेट कर रहा होगा। लेकिन यह प्रश्न समान रूप से शुद्ध वेब-एप्स पर लागू होता है, जहाँ आपके पास कई क्लाइंट्स हो सकते हैं जो डेटाबेस को AngularJS वेब क्लाइंट्स के माध्यम से बदल रहे हैं, और उनमें से प्रत्येक को DB (मॉडल) में बदलाव करने पर अपडेट करने की आवश्यकता होती है।

Question 2

आपके पास कुछ विकल्प हैं ...

आप का उपयोग हर एक्स मिलीसेकेंड मतदान कर सकता है $timeoutऔर $http, या यदि डेटा का उपयोग कर रहे एक बाकी सेवा के शौकीन है, आप इस्तेमाल कर सकते हैं $resourceके बजाय $http।

आप एक ऐसी सेवा बना सकते हैं जो कुछ वेबसोकेट कार्यान्वयन का उपयोग करती scope.$applyहै और सॉकेट द्वारा धकेल दिए जाने वाले परिवर्तनों को संभालने के लिए उपयोग करती है। यहाँ socket.io का उपयोग करके एक उदाहरण दिया गया है, एक नोड .js वेबसोकेट लाइब्रेरी:

myApp.factory('Socket', function($rootScope) {
    var socket = io.connect('http://localhost:3000');

    //Override socket.on to $apply the changes to angular
    return {
        on: function(eventName, fn) {
            socket.on(eventName, function(data) {
                $rootScope.$apply(function() {
                    fn(data);
                });
            });
        },
        emit: socket.emit
    };
})

function MyCtrl($scope, Socket) {
    Socket.on('content:changed', function(data) {
        $scope.data = data;
    });
    $scope.submitContent = function() {
        socket.emit('content:changed', $scope.data);
    };
}

आप वास्तव में उच्च तकनीक प्राप्त कर सकते हैं और एक वेबस्कैट कार्यान्वयन बना सकते हैं जो सर्वर के साथ एक कोणीय मॉडल को सिंक करता है। जब क्लाइंट कुछ बदलता है, तो वह परिवर्तन स्वचालित रूप से सर्वर को भेज दिया जाता है। या यदि सर्वर बदल जाता है, तो यह क्लाइंट को भेज दिया जाता है।
इसका एक उदाहरण एंगुलर के एक पुराने संस्करण में है, फिर से सॉकेट का उपयोग करते हुए ।io: https://github.com/mhevery/angular-node-socketio

संपादित करें : # 3 के लिए, मैं ऐसा करने के लिए फायरबेस का उपयोग कर रहा हूं ।

Question 3

यहां एक कार्यान्वयन है जो नोड के बजाय जेट्टी का उपयोग करता है। Angularjs हिस्सा कोणीय-बीज ऐप पर आधारित है। मुझे यकीन नहीं है कि अगर कोणीय कोड मुहावरेदार है ... लेकिन मैंने परीक्षण किया है कि यह काम करता है। HTH -Todd।

TimerWebSocketServlet देखें

https://gist.github.com/3047812

नियंत्रकों। js

// -------------------------------------------------------------
// TimerCtrl
// -------------------------------------------------------------
function TimerCtrl($scope, CurrentTime) {
    $scope.CurrentTime = CurrentTime;
    $scope.CurrentTime.setOnMessageCB(
        function (m) {
            console.log("message invoked in CurrentTimeCB: " + m);
            console.log(m);
            $scope.$apply(function(){
                $scope.currentTime = m.data;
            })
        });
}
TimerCtrl.$inject = ['$scope', 'CurrentTime'];

सेवाएं .js

angular.module('TimerService', [], function ($provide) {
    $provide.factory('CurrentTime', function () {
        var onOpenCB, onCloseCB, onMessageCB;
        var location = "ws://localhost:8888/api/timer"
        var ws = new WebSocket(location);
        ws.onopen = function () {
            if(onOpenCB !== undefined)
            {
                onOpenCB();
            }
        };
        ws.onclose = function () {
            if(onCloseCB !== undefined)
            {
                onCloseCB();
            }
        };
        ws.onmessage = function (m) {
            console.log(m);
            onMessageCB(m);
        };

        return{
            setOnOpenCB: function(cb){
               onOpenCB = cb;
            },
            setOnCloseCB: function(cb){
                onCloseCB = cb;
            },
            setOnMessageCB: function(cb){
                onMessageCB = cb;
            }
        };
    })});

web.xml

<servlet>
    <servlet-name>TimerServlet</servlet-name>
    <servlet-class>TimerWebSocketServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>TimerServlet</servlet-name>
    <url-pattern>/api/timer/*</url-pattern>
</servlet-mapping>

Question 4

क्या आप देख रहे हैं Firebase और Deployd है । फायरबेस एक एडेप्टर के साथ आता है जो इसे एक हवा का उपयोग करता है: http://angularfire.com/

Question 5

"डिस्कवर मेट्योर" पुस्तक के अनुसार, कोणीय घड़ियाँ / स्कोप, प्रतिक्रियाशीलता के बारे में उल्का की संगणना के समान हैं ... लेकिन एंगुलर क्लाइंट-ओनली है और मेट्योर की तुलना में कम-दानेदार नियंत्रण देता है।

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

Question 6

तो, एंडी जोसलिन ने अपने उत्तर में 3 ऑप्शन में सबसे अच्छा समाधान का उल्लेख किया है, जो कि 3 विकल्प है, जो वेबसाइकेट या जो भी अन्य एसिंक्स लाइब्रेरी आपके साथ काम कर रहा है, उसके माध्यम से राज्य को बनाए रखना है। उदाहरण के लिए ऐप्स), और टॉडग ने एक उदाहरण दिया है कि यह कैसे हासिल किया जाएगा। हालांकि, अपने उदाहरण में वह एंगुलरजेएस में एक विरोधी पैटर्न लागू कर रहा है: सेवा नियंत्रक को बुला रहा है। इसके बजाय, मॉडल को सेवा के अंदर रखा जाना चाहिए, और फिर नियंत्रक से संदर्भित किया जाना चाहिए।

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