Performanceoptimierung bei Social Media Integration
Wer Social Medias auf seiner Webseite integriert, stolpert als erste Hürde über die eigenen APIs der Social Medias, die sich jedoch leicht überwinden lässt wie mein letzter Post zeigt. Die zweite Hürde ist umso grösser: Die Performance der Zugriffe ist denkbar schlecht. Der Flaschenhals ist dabei das Social Media selbst. Facebook schneidet mit Abstand am schlechtesten ab. Selbst wenn die Abfrage stark eingeschränkt wird, kann sie immer noch bis zu 2 Sekunden dauern. Bei Youtube sind die Werte deutlich besser und liegen bei der ersten Abfrage für gewöhnlich unter einer Sekunde und bei einer wiederholten sogar unter einer halben.
Wenn der Channel asynchron geladen wird, ist das alles kein Problem. Wer jedoch auf seiner Webseite kein Busy Gif anstelle der Facebook Posts sehen will, sollte einen anderen Weg gehen. Ich möchte eine Caching Lösung vorstellen, an der ich mitgearbeitet habe. Das Prinzip ist denkbar einfach: Alle Social Media Channels werden jeweils in einem separaten Thread alle 2 Minuten aktualisiert. Die Webseite selbst zeigt die aktuellen Posts immer sofort an und hat so maximal einen veralteten Stand von 2 Minuten. Die Zeit lässt sich natürlich variieren. Der Vorteil liegt auf der Hand: Der Benutzer sieht die gewünschten Daten sofort und merkt nichts davon, dass sie geladen werden müssen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// Base class for social media data providers public abstract class SocialMediaDataProvider { public SocialMediaDataProvider(string channelName, int n) { ChannelName = channelName; N = n; } // Data Providers are equal if their channel names are equal public override bool Equals(object obj) { if (obj is SocialMediaDataProvider) { if (obj != null) { return this.ChannelName.Equals(((SocialMediaDataProvider)obj).ChannelName); } } return base.Equals(obj); } public override int GetHashCode() { return base.GetHashCode(); } public abstract List<Posting> GetTopNPostings(); public int N { get; private set; } public string ChannelName { get; private set; } } |
Davon abgeleitet gibt es je einen Provider für bspw. Facebook, Twitter und Youtube, der die Daten entsprechend lädt. Eine Factory Klasse erstellt anhand einer ID den entsprechenden Subtyp.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Factory for social media data providers public static class SocialMediaDataProviderFactory { public static SocialMediaDataProvider GetSocialMediaDataProvider(string socialID, string channelName, int n) { if (socialID == Constants.FACEBOOK) { return new FacebookDataProvider(channelName, n); } else if (socialID == Constants.TWITTER) { return new Linq2TwitterDataProvider(channelName, n); } else if (socialID == Constants.YOUTUBE) { return new YouTubeDataProvider(channelName, n); } return null; } } |
Der eigentliche Cache funktioniert über einen Timer und lädt die Daten im Hintergrund regelmässig neu, so dass sie jederzeit abgerufen werden können. Der Zugriff über
|
1 |
GetLatestPostings |
verursacht keine Verzögerung, wenn der Channel bereits vorgeladen wurde (beim Applikationsstart). Handelt es sich jedoch um einen neuen Channel, müssen die Daten beim ersten Mal in Echtzeit geladen werden.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
// Holds the latest social media data and reloads them persistently public class SocialMediaDataHolder { private static object _lock = new object(); private const int DELAY_MILLISECONDS = 120000; private static bool _isStarted = false; private static Timer _timer = null; private static List<SocialMediaDataProvider> _dataProviders = new List<SocialMediaDataProvider>(); private static Dictionary<string, List<Posting>> _latestPostings = new Dictionary<string, List<Posting>>(); public static void Start() { lock (_lock) { if (!_isStarted) { _isStarted = true; _timer = new Timer(TimerCallback, null, 0, DELAY_MILLISECONDS); } } } public static void Stop() { lock (_lock) { if (_isStarted) { _timer.Dispose(); } _isStarted = false; } } public static void AddProvider(ID socialId, string channelName, int n) { var provider = SocialMediaDataProviderFactory.GetSocialMediaDataProvider(socialId, channelName, n); AddProvider(provider); } public static void AddProvider(SocialMediaDataProvider provider) { if (provider == null) { return; } lock (_lock) { if (!_dataProviders.Contains(provider)) { _dataProviders.Add(provider); } } } public static void ClearProviders() { lock (_lock) { _dataProviders.Clear(); _latestPostings.Clear(); } } public static void RemoveProvider(string channelName) { var provider = _dataProviders.Where(p => p.ChannelName.Equals(channelName)).FirstOrDefault(); RemoveProvider(provider); } public static void RemoveProvider(SocialMediaDataProvider provider) { if (provider == null) { return; } lock (_lock) { if (_dataProviders.Contains(provider)) { _dataProviders.Remove(provider); } if (_latestPostings.ContainsKey(provider.ChannelName)) { _latestPostings.Remove(provider.ChannelName); } } } public static List<Posting> GetLatestPostings(ID socialId, string channelName, int n) { // provider added on runtime, load data first if (!_latestPostings.ContainsKey(channelName)) { // add new provider var provider = SocialMediaDataProviderFactory.GetSocialMediaDataProvider(socialId, channelName, n); AddProvider(provider); try { List<Posting> newPostings = provider.GetTopNPostings(); _latestPostings.Add(channelName, newPostings); } catch (Exception exc) { // do not touch cached list -> return empty list return new List<Posting>(); } } return _latestPostings[channelName]; } private static void TimerCallback(object state) { foreach (var provider in _dataProviders) { List<Posting> newPostings = null; try { newPostings = provider.GetTopNPostings(); if ((newPostings.Count == 1) && (newPostings[0] is PostingError)) { continue; } } catch (Exception exc) { //Do nothing - do not touch cached list } if (newPostings != null) { if (_latestPostings.ContainsKey(provider.ChannelName)) { _latestPostings[provider.ChannelName] = newPostings; } else { _latestPostings.Add(provider.ChannelName, newPostings); } } } } } |
Der DataHolder kann bereits beim Applikationsstart (im Global.asax) angestossen werden, wenn die zu ladenden Channels bekannt sind. Andernfalls können neue Channels auch zur Laufzeit hinzugeladen werden, wobei es sich empfiehlt möglichst alle Channels schon beim Applikationsstart zu laden.
|
1 2 3 4 5 6 7 8 |
// Global.asax public void Application_Start() { // Start loading 5 social media posts from each facebook and twitter channel repeatedly SocialMediaDataHolder.AddProvider(Constants.FACEBOOK, "MyFacebookChannel", 5); SocialMediaDataHolder.AddProvider(Constants.TWITTER, "MyTwitterChannel", 5); SocialMediaDataHolder.Start(); } |
