48K Views

L’API Twitter: Faire le meilleur hors de Streaming API

Récemment, j’étais venu dans la tâche de mettre en œuvre le Twitter Streaming Api pour traiter les Flux Twitter (Tweets) en temps réel. Plus précisément, l’application à construire devait être en mesure d’écouter les tweets allant de multiples sujets et les utilisateurs (nous allons nous référer à eux comme des pistes), et doit avoir été en mesure de hot-swap ces pistes presque instantanément.

Pas longtemps avant de travailler sur cette application, j’ai eu à accomplir la même tâche dans le contexte de Facebook. Contrairement à Twitter, ce qui rend l’utilisation de leur Api en continu pour fournir aux applications en temps réel des mises à jour, Facebook utilise à la place de Webhooks. Webhooks, étant un HTTP rappel, offrent aux développeurs avec un niveau de sophistication qui est beaucoup plus facile à traiter. Le Streaming Api fournies par Twitter, cependant, exige de votre application afin de maintenir une persistance de la connexion HTTP avec un, de Twitter, de nombreux streaming les points de terminaison. L’écriture d’une application qui s’appuie sur une connexion permanente pour son fonctionnement nous oblige à penser d’une manière légèrement différente que ce que nous sommes censé être utilisé pour tout bâtiment traditionnel de l’application web.

L’ensemble de l’objet de cet article sera sur le développement d’une telle application.

 

Le Twitter Streaming Api

Si vous prenez un coup d’oeil à Twitter de la Documentation du Développeur, vous verrez qu’ils nous offrent avec de l’Api en continu. Bien sûr, ils nous fournissent aussi avec le RESTE des Annonces et des Api, mais pour nos fins, nous allons uniquement nous concentrer sur leurs Streaming Api.

Alors, quels sont exactement les Api en continu? Pour mettre en termes simples, à l’aide de l’Api en continu, votre demande peut établir un faible temps de latence de la connexion avec Twitter streaming les points de terminaison. Une fois qu’une connexion a été établie avec succès, Twitter va envoyer de l’avant tout en temps réel nourrir votre application a demandé pour cette connexion pipeline presque instantanément. Selon les docs:

Les Api en continu de donner aux développeurs une faible latence d’accès à Twitter mondial de flux de Tweet de données. Une bonne mise en œuvre d’un flux de client sera poussé des messages indiquant les Tweets et autres événements ont eu lieu, sans les frais généraux associés à l’interrogation d’un point de terminaison REST.

L’Api en continu nécessite l’a dit une connexion persistante (essentiellement jamais de fin) dans la nature. En substance, c’est similaire à télécharger un infiniment grand de fichiers de votre système va continuer à recevoir des données, sauf si vous avez manuellement mettre fin à la connexion.

Le type de flux de votre application reçoit dépendra du type de cours d’eau que vous allez utiliser. Le Streaming Api permet aux développeurs de trois types de flux:

  • Public Ruisseaux – Flux de données publiques qui coule à travers Twitter. Adapté pour la suite des utilisateurs spécifiques ou des sujets, et l’exploration de données.
  • Flux – Mono-utilisateur ruisseaux, contenant à peu près toutes les données correspondant avec un seul point de vue de Twitter.
  • Flux – La version multi-utilisateur de l’utilisateur des flux. Site flux sont destinés pour les serveurs qui doivent se connecter à Twitter au nom de beaucoup d’utilisateurs.

Comme je l’ai dit plus tôt, les aliments que nous recevons dépend du type de cours d’eau que nous allons utiliser. Donc avant d’aller plus loin, jetons un regard sur les exigences de notre application, selon nous allons utiliser soit des Flux d’Utilisateur ou de cours d’eau (Site, les Flux sont en bêta fermée).

Notre application doit satisfaire aux exigences suivantes:

  • Écoutez en direct les tweets pour les pistes que nous avons demandé
  • Être en mesure de traiter le reçu des tweets sans interrompre la connexion avec le streaming de point de terminaison
  • Être en mesure de basculer ces pistes qu’ils sont en train d’être changé avec le moins d’interruption de ladite connexion

Garder à l’esprit ces exigences, nous avons maintenant à installer sur le flux que nous allons utiliser. L’utilisateur ruisseaux, comme indiqué précédemment, fournit des données provenant d’un utilisateur en particulier du point de vue. Selon Twitter de la documentation de l’Utilisateur Ruisseaux:

Utilisateur Flux de fournir un flux de données et d’événements spécifiques à l’utilisateur authentifié. Notez que l’Utilisateur les Flux ne sont pas prévu pour le serveur-à-serveur de connexions. Si vous avez besoin de faire les connexions sur le compte de plusieurs utilisateurs à partir de la même machine, pensez à utiliser le site ruisseaux.

Minimiser le nombre de connexions de votre application permet à l’Utilisateur de Ruisseaux. Chaque compte Twitter est limitée à seulement quelques simultanée de l’Utilisateur de Flux de connexions par OAuth application, indépendamment de la propriété intellectuelle. Une fois l’application par application de la limite est dépassée, le plus ancien de la connexion sera interrompue. Un compte d’exploitation forestière dans de trop nombreux cas, de la même OAuth application du cycle de connexions que les instances de l’application rebranchez-le et débranchez les uns des autres.

Depuis que nous sommes plus concentrés sur le fait d’être en mesure de recevoir les tweets de nombreux utilisateurs, il n’est pas clair que le nombre d’utilisateurs qui seront. En passant par la documentation, l’Utilisateur Flux n’est pas suffisant pour notre application de cas d’utilisation. Alors maintenant, nous sommes de gauche à faire avec le Public Flux.

, par opposition à l’Utilisateur de Flux, ce qui nous permet de recevoir des flux dans le cadre limité d’utilisateurs individuels, Publics Flux de fournir aux applications un flux de données publiques qui coule à travers Twitter. S’exprimant dans le cadre de tweets plus précisément, si nous utilisons public flux intelligemment, notre application ne sera pas tenu de la portée limitée des utilisateurs individuels, contrairement à l’Utilisateur de Ruisseaux. Depuis que nous avons ne sont pas nécessairement concernés confidentielles flux de données, nous pouvons passer sur Twitter officiel (@nom d’utilisateur) correspondant à chaque Utilisateurs de Twitter ainsi que des pistes avant d’établir une connexion avec le public streaming de point de terminaison. Cela permettra à notre application pour écouter en direct du public les tweets de plusieurs utilisateurs. Un point rapide pour avis avant d’aller plus loin, comme par le Twitter de la Documentation pour le Public, de Ruisseaux, notre application ne peut établir une connexion unique avec un public cours d’eau à tout moment.

 

la Communication avec l’API en continu: la Construction de notre demande

Maintenant que nous avons terminé avec tous l’introduction de bits, nous pouvons commencer à construire notre application. Je vais être le développement de l’application en PHP sous Linux, en utilisant le populaire Framework Symfony et Compositeur que le gestionnaire de package. Cela étant dit, vous devriez être en mesure d’appliquer les concepts fondamentaux et de mettre en œuvre le projet dans la langue de votre choix.

cependant, je vais être à l’aide de Phirehose par Fennb, une bibliothèque tierce, afin de faciliter le processus de communication avec le Twitter Api en continu. Si vous êtes en développement sur la plate-forme autre qu’en PHP, voici une liste extensive de les bibliothèques de tiers vous pouvez faire usage de. Vous pouvez ajouter Phirehose pour votre projet via Composer à l’aide de la commande suivante:

php compositeur besoin “fennb/phirehose”

 

mise en place de notre demande:

Créer un nouveau projet Symfony (appelons-la  » twitterFeeds) en exécutant la commande suivante:

symfony nouveau twitterFeeds

Avant de nous déplacer le long de avec l’article, assurez-vous que vous avez installé la bibliothèque tierce, comme mentionné ci-dessus. Ensuite, créez un nouveau bundle (appelons ce TwitterBundle) en exécutant la commande suivante:

php bin/console generate:bundle

Suivre ainsi que tout ce que les détails de la configuration est demandé de vous. Ensuite, allez à votre TwitterBundle répertoire de votre projet et de créer un nouveau Services répertoire. Dans ce répertoire, créez un nouveau fichier nommé TwitterService.php qui nous allons utiliser. Assurez-vous de vous inscrire à ce service pour votre application.

 

l’Établissement d’une connexion persistante:

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Command;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class TwitterCommand extends ContainerAwareCommand
{
	protected function configure()
	{
		$this->setName('twitter:stream')->setDescription('Listen for Live Twitter Feeds.');
	}

	protected function execute(InputInterface $input, OutputInterface $output)
	{
		$twitterTracks = ['#ReasonsToLoveMe']; // Define your tracks you wish to receive updates for
		$this->getContainer()->get('twitter.service')->listenForTweets($twitterTracks); // This will start the streaming process
	}
}

dans le répertoire racine de notre projet, nous pouvons maintenant exécuter du code écrit dans le execute() de la fonction à l’aide de la commande suivante dans le terminal:

php bin/console twitter:stream

Comme on peut le voir, le TwitterCommand::execute() fonction, à son tour, appeler le TwitterCommand::listenForTweets() de la fonction définie dans le TwitterService, qui va établir une nouvelle connexion persistante avec Twitter streaming de point de terminaison. Donc, nous allons coder ce jusqu’à la prochaine. Dans votre TwitterService.php que nous avons créé plus tôt,

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Services;

const CONSUMER_KEY = YOUR_APP_CONSUMER_KEY;
const CONSUMER_SECRET = YOUR_APP_CONSUMER_SECRET;
const APPLICATION_TOKEN = YOUR_APP_ACCESS_TOKEN;
const APPLICATION_TOKEN_SECRET = YOUR_APP_ACCESS_TOKEN_SECRET;

// Include the third-party library
require_once __DIR__ . '/../../../vendor/fennb/phirehose/lib/OauthPhirehose.php';

class TwitterListener extends \OauthPhirehose
{
    public function __construct() {
        parent::__construct(APPLICATION_TOKEN, APPLICATION_TOKEN_SECRET, \Phirehose::METHOD_FILTER);
        $this->consumerKey = CONSUMER_KEY;
        $this->consumerSecret = CONSUMER_SECRET;
    }

    public function enqueueStatus($status)
    {   
        $twitterFeed = json_decode($status, true);
        if (is_array($twitterFeed) && isset($twitterFeed['user']['screen_name'])) {
            $twitterData = array('feed' => $twitterFeed);
            dump('New Feed Recieved');
            dump($twitterData);
        }
    }
}

class TwitterService
{
	/**
	 * This function will establish a persistent connection with one of the twitter's streaming endpoint.
	 * @param  array  $twitterTrackCollection Collection of tracks which we'll receive updates for
	 */
	public function listenForTweets(array $twitterTrackCollection = [])
    {
    	// Terminate the process if there are no active tracks
    	if (empty($twitterTrackCollection)) {
    		echo 'No active tracks. Terminating Process...' . PHP_EOL . PHP_EOL;
    		exit(0);
    	}

    	$twitterListener = new TwitterListener();
        $twitterListener->setTrack($twitterTrackCollection);
        $twitterListener->consume();
    }
}

Maintenant, si vous exécutez la commande que nous venons de créer à partir de votre terminal, une nouvelle connexion avec Twitter API en continu sera mis en place et vous allez commencer à recevoir du public des tweets pour les pistes que vous avez défini. Au moment de la rédaction de cet article, “#ReasonsToLoveMe” a été orientées j’ai donc utilisé que comme un exemple à suivre. Maintenant, à chaque fois un tweet est fait qui se compose d’une de nos pistes (dans ce cas, “#ReasonsToLoveMe”), ce tweet sera transmise en bas de la connexion de la canalisation. Ce tweet sera alors transmis au TwitterListener::enqueueStatus() de la fonction, où vous pouvez traiter la réception de l’alimentation. Cependant, vous devriez éviter de faire tout le temps de fonctionnement intensif à ce point. La raison étant que, si votre demande est incapable de traiter ce flux de données assez rapidement en contraste avec le taux que vous recevez le flux, vous risquez d’avoir votre connexion terminée, pour la plupart d’entre nous ne serait pas souhaitable.

Temps Réel des Flux Twitter

en Temps Réel des Flux Twitter

Jusqu’à maintenant, nous avons été de démarrer manuellement la connexion en allant à notre terminal et exécuter la commande. Mais depuis des applications du monde réel sont très différentes, nous allons automatiser ce processus de démarrage et la fermeture de la connexion. Dans notre DefaultController, nous allons écrire une action gestionnaire (nous l’appellerons ce startStreamAction), qui lorsqu’il est exécuté appliquerons notre processus de diffusion. Assurez-vous que vous avez configuré le parcours de ce maître, à la correspondante routage.yml fichier. Dans DefaultController.php

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class DefaultController extends Controller
{
    // .....

    /**
     * This handler will switch to the root directory and start a new background process
     */
    public function startStreamAction(Request $request)
    {
        chdir('../');
        $command = 'php bin/console twitter:listen';
        exec($command);
        exit(0);
    }

    // .....
}

Maintenant, chaque fois que nous visitons la route pour ce gestionnaire, cette commande sera exécutée séparément dans un nouveau thread.

Public Ruisseaux, nous ne recevons que les flux publics pour les pistes que nous avons définie avant l’établissement d’une connexion persistante avec le streaming de point de terminaison. Donc, si un besoin se fait sentir de mettre à jour notre élan, nous devons mettre fin à la connexion précédente, re-définir nos traces, et puis re-établir une nouvelle connexion avec le streaming de point de terminaison. Ce processus est très critique car on ne peut avoir qu’une seule connexion avec le streaming de point de terminaison à un moment (nous risquons d’avoir nos droits de propriété intellectuelle interdit les connexions multiples). Donc, nous devons faire en sorte que, avant de tenter de créer une nouvelle connexion, tous précédemment occupé les connexions sont fermées.

Pour fermer une connexion avec le streaming de point de terminaison, nous pouvons résilier le processus d’arrière-plan correspondant à la connexion. Pour tuer le processus, nous pouvons soit utiliser ID de processus (PID), ou de chercher en utilisant le nom et les arguments des processus d’arrière-plan. À l’aide de l’ID de processus, chaque fois que nous établir une nouvelle connexion, nous allons avoir besoin de log (base de données, fichier texte, etc…) l’ID de processus correspondant à ce processus en arrière-plan. À l’aide de ce journal, vous pouvez alors résilier précédemment tenu des processus d’arrière-plan avant de lancer un nouveau. Nous allons mettre à jour notre startStreamAction gestionnaire de journal de l’ID de processus chaque fois qu’une connexion est faite, et en notre DefaultController, créez une nouvelle action de gestionnaire (appelons ce stopStreamAction) pour mettre fin à toute précédemment tenu des processus d’arrière-plan. On peut alors appeler cette fonction avant de commencer un nouveau processus d’arrière-plan pour s’assurer qu’une seule instance d’une connexion persistante avec le streaming de point de terminaison est active à un moment.

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class DefaultController extends Controller
{
    // ......

    /**
     * This handler will first terminate any previously held background process  
     * by firing the stopStreamAction() handler. Then it'll create a new background  
     * process which establish a new connection with a streaming endpoint.
     */
    public function startStreamAction(Request $request)
    {
    	// Execute the stopStreamAction() handler
        $curlHandler = curl_init();
        $stopStreamPath = $this->generateUrl('twitter_stream_stop', array(), UrlGeneratorInterface::ABSOLUTE_URL);
        curl_setopt($curlHandler, CURLOPT_URL, $stopStreamPath);
        curl_setopt($curlHandler, CURLOPT_RETURNTRANSFER, 1);
        curl_exec($curlHandler);

        // Create a new background process
        chdir('../');
        $output = array();
        $command = 'nohup php bin/console twitter:listen > /dev/null 2>&1 & echo $!';
        exec($command, $output);
        $processId = (int) $output[0]; // Process ID of the newly created background process. Log this.
        exit(0);
    }

    /**
     * This handler will fetch a log of Process IDs corresponding to any background
     * process and terminate them.
     */
    public function stopStreamAction(Request $request)
    {
        $activeProcesses = ARRAY_COLLECTION_OF_PROCESS_IDS_TO_TERMINATE;

        if (!empty($activeProcesses)) {
            foreach ($activeProcesses as $processId) {
                $command = 'kill ' . $processId . ' 2>&1';
                exec($command, $output);
                $this->get('logger')->info('Twitter Stream Process Terminated: ' . $processId);
            }
        }
        exit(0);
    }

    // ......
}

Si vous regardez attentivement, nous avons modifié la commande que nous allons exécuter à partir du terminal à l’aide de la exec() de la fonction.

nohup php bin/console twitter:écouter > /dev/null 2>,&1 & echo $!

Tous les morceaux seront de retour l’ID de processus du processus d’arrière-plan créé par la fonction exec (). Maintenant, chaque fois qu’un nouveau processus d’arrière-plan est créé suivant cette approche, l’ensemble de nos précédemment tenu des processus d’arrière-plan sera terminé (le cas échéant). Cela devrait être plus que suffisant pour s’assurer qu’une seule connexion est active à un moment, à condition de bien vous connecter leur Id de processus. Vous pouvez améliorer cette fonctionnalité en fonction de vos besoins.

Tout ce qui reste maintenant est de traiter le flux de données que nous allons recevoir par le biais de la connexion de la canalisation. Pour ce faire, nous allons faire de l’amélioration de notre Service Twitter (TwitterService.php) dans un premier temps, puis de rediriger tout les tweets que notre application reçoit un gestionnaire (appelons ce processStreamAction) qui, à son tour, le processus de ces tweets. Dans votre TwitterService.php

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Services;

const CONSUMER_KEY = YOUR_APP_CONSUMER_KEY;
const CONSUMER_SECRET = YOUR_APP_CONSUMER_SECRET;
const APPLICATION_TOKEN = YOUR_APP_ACCESS_TOKEN;
const APPLICATION_TOKEN_SECRET = YOUR_APP_ACCESS_TOKEN_SECRET;

require_once __DIR__ . '/../../../vendor/fennb/phirehose/lib/OauthPhirehose.php';

class TwitterListener extends \OauthPhirehose
{
    private $curlHandler = null;
    private $processStreamPath = null;

    public function __construct() {
        parent::__construct(APPLICATION_TOKEN, APPLICATION_TOKEN_SECRET, \Phirehose::METHOD_FILTER);
        $this->processStreamPath = URL_TO_PROCESS_STREAM_ACTION_HANDLER;
        $this->consumerKey = CONSUMER_KEY;
        $this->consumerSecret = CONSUMER_SECRET;
        $this->configureCURL();
    }

    private function configureCURL()
    {
        $this->curlHandler = curl_init();
        $headers = array('Content-type: multipart/form-data');
        curl_setopt($this->curlHandler, CURLOPT_POST, true);
        curl_setopt($this->curlHandler, CURLOPT_URL, $this->processStreamPath);
        curl_setopt($this->curlHandler, CURLOPT_RETURNTRANSFER, 1);
    }

    public function enqueueStatus($status)
    {   
        $twitterFeed = json_decode($status, true);
        if (is_array($twitterFeed) && isset($twitterFeed['user']['screen_name'])) {
            $twitterData = array('feed' => $twitterFeed);
            curl_setopt($this->curlHandler, CURLOPT_POSTFIELDS, http_build_query($twitterData));
            curl_exec($this->curlHandler);
        }
    }
}

class TwitterService
{
	/**
	 * This function will establish a persistent connection with one of the twitter's streaming endpoint.
	 * @param  array  $twitterTrackCollection Collection of tracks which we'll receive updates for
	 */
	public function listenForTweets(array $twitterTrackCollection = [])
    {
    	// Terminate the process if there are no active tracks
    	if (empty($twitterTrackCollection)) {
    		echo 'No active tracks. Terminating Process...' . PHP_EOL . PHP_EOL;
    		exit(0);
    	}

    	$twitterListener = new TwitterListener();
        $twitterListener->setTrack($twitterTrackCollection);
        $twitterListener->consume();
    }
}

Maintenant, chaque fois qu’un flux twitter est reçu, TwitterListener::enqueueStatus() va de l’avant l’alimentation de la route, nous avons spécifié à l’aide de CURL en faisant une requête POST. En fait, c’est exactement comme un Webhook si vous pensez à ce sujet. Maintenant, nous allons écrire le processStreamAction() gestionnaire dans notre DefaultController. Dans votre DefaultController.php

/**
 * Webkul Software.
 *
 * @category	Webkul, Uvdesk
 * @package		Webkul_UVDesk_TF
 * @author		Akshay Kumar
 * @copyright	Copyright (c) 2010-2016 Webkul Software Private Limited (https://webkul.com)
 * @license 	https://store.webkul.com/license.html
 */

namespace TwitterBundle\Controller;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class DefaultController extends Controller
{
    /**
     * This handler will first terminate any previously held background process  
     * by firing the stopStreamAction() handler. Then it'll create a new background  
     * process which establish a new connection with a streaming endpoint.
     */
    public function startStreamAction(Request $request)
    {
    	// Execute the stopStreamAction() handler
        $curlHandler = curl_init();
        $stopStreamPath = $this->generateUrl('twitter_stream_stop', array(), UrlGeneratorInterface::ABSOLUTE_URL);
        curl_setopt($curlHandler, CURLOPT_URL, $stopStreamPath);
        curl_setopt($curlHandler, CURLOPT_RETURNTRANSFER, 1);
        curl_exec($curlHandler);

        // Create a new background process
        chdir('../');
        $output = array();
        $command = 'nohup php bin/console twitter:listen > /dev/null 2>&1 & echo $!';
        exec($command, $output);
        $processId = (int) $output[0]; // Process ID of the newly created background process. Log this.
        exit(0);
    }

    /**
     * This handler will fetch a log of Process IDs corresponding to any background
     * process and terminate them.
     */
    public function stopStreamAction(Request $request)
    {
        $activeProcesses = ARRAY_COLLECTION_OF_PROCESS_IDS_TO_TERMINATE;

        if (!empty($activeProcesses)) {
            foreach ($activeProcesses as $processId) {
                $command = 'kill ' . $processId . ' 2>&1';
                exec($command, $output);
                $this->get('logger')->info('Twitter Stream Process Terminated: ' . $processId);
            }
        }
        exit(0);
    }

    /**
     * A POST request will be made to this handler whenever our application receives
     * a feed. You can write your implementation here.
     */
    public function processStreamAction(Request $request)
    {
        if (isset($_POST)) {
            if (array_key_exists('feed', $_POST)) {
            	// Real-time Twitter Feed. Write your own implementation over here.
                $streamContent = $_POST['feed'];
            }
        } else {
            // Request method not supported.
        }
        exit(0);
    }
}

Là vous allez! Maintenant, nous avons entièrement fonctionnelle d’une application qui ne sera pas seulement d’écouter les flux en direct à partir de Twitter pour les pistes, mais nous permet également de mettre à jour nos pistes presque instantanément, tout en veillant à ce qu’une seule connexion avec le streaming de point de terminaison est active à un moment. Vous pouvez étendre cette application à votre goût et le rendre plus robuste et tolérant aux pannes. Ici, dans le UVDesk, nous avons suivi une approche similaire pour fournir à nos Utilisateurs de Twitter avec une meilleure expérience utilisateur et la connectivité sociale.

Category(s) uvdesk
. . .

Comment

Add Your Comment

Be the first to comment.

css.php