ROAE-Blog » PHP

Punkte in Google-Mail-Adressen

Felix — Tue, 18 May 2010 18:09:29 +0000

Registriert man bei Google Mail eine E-Mailadresse – z.B. dasIstEineEMailAdresse@googlemail.com – so wird der komplette Benutzername unabhängig von Groß-/Kleinschreibung und Punkten (.) interpretiert: registriert man die E-Mail-Adresse dasIstEineEMailAdresse@googlemail.com, so hat man automatisch auch folgende weitere Adressen das.ist.eine.emailadresse@googlemail.com oder das.istEineEmailAdresse@googlemail.com etc.

Welche Vorteile sich für den Benutzer und welche Nachteile für einen Webmaster sich hierdurch ergeben soll hier kurz aufgezeigt werden.

Vorteile für den Benutzer

Durch unterschiedliche E-Mail-Adressen, welche aber alle zu einem Postfach führen, gibt es für den Benutzer eine Reihe von Vorteilen.

Organisation/Kategorisierungen

Der Benutzer kann die E-Mails besser organisieren bzw. kategorisieren. Beispielsweise wird für alle Newsletter die E-Mail-Adresse m.ax.mueller@googlemail.com verwendet, für den privaten Kontakt max.mueller@googlemail.com. Mit Hilfe der Filtereinstellungen bei Google-Mail können dann alle Newsletter unabhängig vom Absender mit einem Label versehen und aus dem Posteingang verschoben werden – so findet man im Posteingang dann wirklich nur die “wichtigen” E-Mails.

Privatsphäre

Manche Plattformen bieten die Möglichkeit über eine E-Mail-Adresse zu prüfen ob ein User angemeldet ist (z.B. Facebook). Dies ist nicht von jedem User gewünscht. Hier bietet sich dann mit einer Google-Mail-Adresse die Möglichkeit seine E-Mail-Adresse auf der Plattform z.B. auf max.m.u.e.l.l.e.r@googlemail.com zu ändern. Sucht ein User nach max.mueller@googlemail.com so wird er nicht fündig werden – und trotzdem muss man nicht eine weitere E-Mail-Adresse registrieren.

Nachteile für den Webmaster

Natürlich ergeben Sie durch dieses Feature auch Nachteile. Oft wird die E-Mail-Adresse als primary Key verwendet um so Mehrfachanmeldungen oder Nutzungen schnell und einfach zu unterbinden. Dies wird genutzt unter anderem bei:

Serialversand
Das Produkt X darf 14 Tage mit der Serial Y getestet werden. Wird danach versucht erneut eine Serial anzufordern, schlägt das für die benutzte Adresse fehl
Unterbinden von Mehrfachregistrierung
Es soll verhindert werden dass sich ein Benutzer mehrfach registriert – unabhängig ob das Verhalten gewollt oder ungewollt ist. Sei es auf Community-Seiten oder auch finanziell orientierten Homepages wie Online-Shops.

Natürlich gibt es neben der “Google-Mail-Problematik” auch noch andere Möglichkeiten wie Wegwerf-E-Mail-Adressen, Automatische Erstellung von E-Mail-Konten, oder sogar der Besitz einer (E-Mail-)Domain (ich@meineDomain.de, ich1@meineDomain.de, …). Wir wollen uns aber hier nur mit Google-Mail beschäftigen.

Eine Möglichkeit das Problem zu umgehen ist der folgende einfache Algorithmus:

Prüfe ob Google-Mail-Adresse
Wenn Ja entferne im Benutzername alle Punkte
Speichere E-Mail-Adresse

Wenn nun geprüft werden soll, ob ein Account schon eine E-Mail-Adresse verwendet, wird auf diese der Algorithmus angewandt, und dann z.B. die Datenbank nach der Mail-Adresse durchsucht. Bleibt die Suche erfolglos, darf sich der User registrieren, wenn nicht, ist der User wohl mit einer ähnliche Adresse bereits registriert und sollte darauf hingewiesen werden. Wichtig ist hierbei, dass der Datenbestand, in dem die Mail-Adresse gesucht wird, bereits die “gesäuberte Adressen” besitzt.

Hinweis: Bei Google-Mail sind gmail.com und googlemail.com möglich. Dies wird vom Script entsprechend beachtet und alle Adressen auf gmail.com umgeschrieben.

Die Implementierung könnte in PHP z.B. gefolgt aussehen:

/**
 * Cleans an e-mail-address (especially Google-Mail-adresses) to avoid duplicates.
 * @param String $emailStr e-mail-address
 */
function clean_email($emailStr) {
	$emailStr = strtolower ($emailStr);
	$tokens = preg_split ("/@/", $emailStr);

	if ($tokens [1] == "gmail.com" || $tokens [1] == "googlemail.com") {
		return str_replace (".", "", $tokens [0]) . "@googlemail.com";
	} else {
		return $emailStr;
	}
}

Ein Aufruf von

echo clean_email("m.a.x.MUELLE.R@gmail.com") . "
";
echo clean_email("m.a.x.MUELLE.R@googlemail.com") . "
";
echo clean_email("max.mueller@web.de");

hat dann entsprechende folgende Ausgabe:

maxmueller@googlemail.com
maxmueller@googlemail.com
max.mueller@web.de

Epilog

Nicht immer wenn sich ein User versucht nochmal zu registrieren ist dies beabsichtigt. Ggf. hat der User schlicht vergessen dass er auf einer Seite registriert ist, oder kann sich nicht mehr einloggen, weil er seine Logindaten nicht mehr kennt. Deshalb sollte immer eine entsprechende Meldung ausgegeben werden wie z.B. “Es ist bereits ein User mit dieser E-Mail-Adresse registriert. Haben Sie Ihr Passwort vergessen?” mit entsprechenden Link zu einer Seite, wo ein neues Passwort beantragt werden kann.

Auch ist bei Prüfung auf Google-Mail-Adressen und Wegwerf-Adressen natürlich nicht vor einer Mehrfachregistrierung geschützt. Sicher ist das nur über das kostenpflichtige und zeitaufwendige Postident-Verfahren – was jedoch im Internet an der Praxis scheitert.

Weitere Informationen:

PHP und Geolocation – Lokalisierung leicht gemacht

Philipp — Sun, 09 May 2010 17:39:03 +0000

Ein Besuch auf www.regnets.in zeigt kurz und knapp die aktuelle Wetterlage für den Standort des Besuchers an. Ermöglicht wird das über Geolocation anhand der IP-Adresse des Benutzers. Natürlich kann der Benutzer auch andere Städte abfragen: www.regnets.in/Hamburg oder www.regnets.in/Berlin.

Geolocation lässt sich beispielsweise mit (kostenlosen) GeoLite City von MaxMind sehr einfach in PHP-Projekte integrieren. Mit nur wenigen Dateien und wenigen Zeilen Code lässt sich so der Standort des Besuchers relativ genau (für Deutschland mit 71% Trefferquote) bestimmen.

Die benötigten Dateien…

geoip.inc
geoipcity.inc
geoipregionvars.php
GeoLiteCity.dat – die eigentliche Datenbank

… lassen sich hier herunterladen.

Folgender PHP Code liefert die Geolocation des Besuchers:

include("geoipcity.inc");
include("geoipregionvars.php");

function getCity() {

	$gi = geoip_open("GeoLiteCity.dat", GEOIP_STANDARD);
	$record = geoip_record_by_addr($gi, $_SERVER['REMOTE_ADDR']);
	geoip_close($gi);

	return $record->city;
}

Das $record-Objekt enthält aber auch noch andere, interessante Daten:

print $record->country_code . " " . $record->country_code3 . " " . $record->country_name . "\n";
print $record->region . " " . $GEOIP_REGION_NAME[$record->country_code][$record->region] . "\n";
print $record->city . "\n";
print $record->postal_code . "\n";
print $record->latitude . "\n";
print $record->longitude . "\n";
print $record->metro_code . "\n";
print $record->area_code . "\n";

Fragen, Anregungen? Dafür sind die Kommentare da!

fsockopen statt file_get_contents für HTTP-Requests

Felix — Fri, 16 Apr 2010 13:00:05 +0000

Bei zahlreichen Webspace-Providern ist die Funktionalität von file_get_contents für http deaktiviert. Es treten dann Fehlermeldungen wie

Warning: file_get_contents() [function.file-get-contents]: URL file-access is disabled in the server configuration in [..] und

Warning: file_get_contents([..]) [function.file-get-contents]: failed to open stream: no suitable wrapper could be found in [..]

auf. Mit folgender Funktion kann man das Verhalten von file_get_contents jedoch emulieren.

Die Funktion get_contents_by_uri benutzt fsockopen um Inhalte zu laden:

/**
 * Gets contents of any webside by an URI.
 * @author http://blog.root-of-all-evil.com
 * @param String $uri
 */
function get_contents_by_uri($uri) {
	$uriElem = parse_url ( $uri );
	$fp = @fsockopen ( $uriElem ['host'], 80, $errno, $errstr, 10 );

	if (! $fp) {
		throw new Exception ( "Could not create socket: '" . $errnstr . "' (" . $errno . ")." );
	}

	$request = "GET " . $uriElem ['path'] . (isset ( $uriElem ['query'] ) ? "?" . $uriElem ['query'] : "") . " HTTP/1.1\r\n";
	$request .= "Host: " . $uriElem ['host'] . "\r\n";
	$request .= "Connection: Close\r\n\r\n";

	fwrite ( $fp, $request );
	$response = "";
	while ( ! feof ( $fp ) ) {
		$response .= fgets ( $fp, 128 );
	}
	fclose ( $fp );

	// split headers from data
	$responseSplit = explode ( "\r\n\r\n", $response, 2 );

	return $responseSplit [1];
}

Erklärung

Socket erstellen

Die übergebene URI wird über die PHP-Funktion parse_url in ihre Teilmengen zerlegt. Anschließend wird ein Socket erstellt für den entsprechenden Host, auf Port 80 mit einem Timeout von 10 Sekunden. Fehlermeldungen unterdrücken wir durch das @, da wir explizit nach Erfolg abfragen und ggf. eine Ausnahme werfen.

Anfrage schicken, Antwort lesen

Danach wird über fwrite eine entsprechende GET-Anfrage geschickt, welche auch – falls vorhanden – die Parameter der URI und nicht nur den Pfad beachtet. Die darauffolgende Antwort wird in die Variable response gelesen.

Antwort bearbeiten und zurückgeben

Da diese neben dem eigentlichen Inhalt auch den Antwortheader enthält wird die Funktion explode benutzt um den Inhalt davon abzuschneiden. Durch den dritten Parameter bei explode mit dem Wert 2, stellen wir sicher, dass nur einmalig an Hand einer Leerzeile getrennt wird wie Sie sich zwischen Antwort-Header und HTML-Code befindet und nicht mehrmals, da natürlich auch Leerzeilen im HTML-Code selbst auftreten können.

Das zweite Element von responseSplit wird zurückgegeben, responseSplit[0] würde entsprechend den Antwort-Header liefern.

Beispielaufrufe

Der einfachste Aufruf:

echo get_contents_by_uri ( 'http://www.google.de/' );

Aufruf mit Parametern:

echo get_contents_by_uri ( 'http://www.google.de/search?hl=de&site=&q=test' );

Aufruf mit Ausnahmebehandlung:

try{
    echo get_contents_by_uri ( 'http://does_not_exist_.com/bogus.html' );
}
catch(Exception $e)
{
    echo "get_contents_by_uri: ".$e->getMessage();
}

Weitere Links:

Validierung von URLs mit Zend_Validate

Felix — Fri, 09 Apr 2010 09:45:38 +0000

Dieser Beitrag beschreibt kurz wie man mit Zend_Validate prüfen kann, ob eine URL / URI syntaktisch korrekt und die verlinkte Ressource erreichbar ist.

Aufbau einer URL prüfen

Ein eigenständiger Validator ist im Zend Framework nicht vorhanden welcher den Aufbau einer URL / URI prüft. Jedoch bietet Zend_URI mit der Methode check() hier eine entsprechende Funktionalität an. Auf diese greifen wir in einem selbst geschriebenen Validator zurück:

class Validator_Uri extends Zend_Validate_Abstract {
	const INVALID_URI = 'invalidUri';
	protected $_messageTemplates = array (self::INVALID_URI => "'%value%' is not a valid URI" );

	public function isValid($value) {
		$this->_setValue ($value);

		if (! Zend_Uri::check ($value)) {
			$this->_error ( self::INVALID_URI );
			return false;
		}

		return true;
	}
}

Erreichbarkeit einer URL prüfen

Es ist nicht nur wichtig, dass die Ressourcenangabe in Ihrem Aufbau korrekt ist, sondern auch, dass sich dahinter ein erreichbares Objekt (Webseite, Bild, PDF etc.) befindet.
Mit Hilfe der PHP-Funktion get_headers prüfen wir den Antwort-Header auf Erfolg (200 OK). Mit Hilfe des @ unterdrücken wir eine Fehler-Ausgabe von PHP, wenn der String an get_headers keine URL sein sollte:

class Validator_Uri_Reachable extends Zend_Validate_Abstract {
	const URI_REACHABLE = 'uriReachable';
	protected $_messageTemplates = array (self::URI_REACHABLE => "'%value%' not reachable" );

	public function isValid($value) {
		$this->_setValue ( $value );

		$headers = @get_headers ( $value );
		if (! preg_match ( '/200 OK/', $headers [0] )) {
			$this->_error ();
			return false;
		}

		return true;
	}
}

Entsprechend kann dann in einem Zend-Formular z.B. eine Homepageadresse geprüft werden:

$hpUrl = new Zend_Form_Element_Text ( 'hpUrl' );
$hpUrl->setLabel ( 'Homepage:' )
			  ->setDescription ( 'Ihre Homepage- oder Blog-Adresse' );
			  ->setAttrib ( 'value', 'http://' )
			  ->addValidator ( new Validator_Uri() )
			  ->addValidator ( new Validator_Uri_Reachable() )

Weitere Links:

eBay Trading API Codeschnipsel – Teil 1

Philipp — Wed, 07 Apr 2010 16:54:55 +0000

Converting ISO 8601 Duration Time Format in PHP

This little sniplet will enable you to parse ISO 8601 Period (Duration) Time Formats into seconds. The ISO 8601 Period is represented by a string like PnYnMnDTnHnMnS where nY represents the number of years, nM the months, nD the days, nH the hours, nM the Minutes and nS the Seconds. The T seperates the date (to the left of the T) from the time (to the right of the T). Parsing this string is quite tricky, because unneeded values (like years and months for durations shorter than a month) can be left out. Parsing is also tricky, because we face two “M” as identifiers (for months and Minutes).

// ISO 8601 period format PnYnMnDTnHnMnS (e.g., P0Y0M2DT23H32M51S) to seconds
function calcFinishTime($timeleft)
{
	$parsed = array('Y' => 0, 'Mo' => 0, 'D' => 0, 'H' => 0, 'Mi' => 0, 'S' => 0);
	$calcSec = array(12, 31, 24, 60, 60);
	$toParse = preg_split('/T/', strtoupper($timeleft));
	foreach($toParse as $i => $array) {
		$split = preg_split('/([PYMDTHMS]+)/', $array, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
		$count = count($split);
		for($j = 0; $j < $count; $j++) {
			if(is_numeric($split[$j])) {
				$type = substr($split[$j +1], 0, 1);
				if($i < 1 && $type == 'M')	$type = 'Mo';
				elseif($type == 'M')		$type = 'Mi';
				$parsed[$type] += (int)$split[$j];
			}
		}
	}
	$k = 0;
	foreach($parsed as $type) {
		$sec = 1;
		for($j = $k; $j < 5; $j++) {
			$sec *= $calcSec[$j];
		}
		$parsed['seconds'] += $sec * $type;
		$k++;
	}
	$parsed['endtime'] = time() + $parsed['seconds'];
	return $parsed;
}

A input of “P2DT3H6M24″ will result in an array like this:

array(8) {
  ["Y"]=>
  int(0)
  ["Mo"]=>
  int(0)
  ["D"]=>
  int(2)
  ["H"]=>
  int(3)
  ["Mi"]=>
  int(6)
  ["S"]=>
  int(24)
  ["seconds"]=>
  int(183984)
  ["endtime"]=>
  int(1270843142)
}

Thumbnails erzeugen und Durchschnittsfarbe in PHP ermitteln

Philipp — Thu, 18 Feb 2010 19:36:22 +0000

Eines meiner etwas zurückliegenden Projekte zwang mich externe Bilder durch meinen Server zu laden, zu verkleinern und schließlich auch die Durchschnittsfarbe zu berechnen. Aus Gründen der Performancesteigerung war ich nie ein Fan davon die Durchschnittsfarbe Pixel für Pixel des Originalbildes zu berechnen. Es gibt eine viel elegantere und fast genauso exakte Lösung:

Unser Ziel: Wir möchten ein Bild (jpg, gif, png) über einen HTTP-Stream laden, dieses lokal auf dem Server speichern, ein entsprechendes Thumbnail (eine verkleinerte Version) erzeugen, speichern und schlussendlich die dominierende – oder auch durchschnittliche – Farbe im Bild berechnen und abspeichern. Eventuell möchten wir zusätzlich alles in einer Datenbank hinterlegen – das soll aber zunächst außerhalb unserer Betrachtung liegen.

Für das Berechnen der Durchschnittsfarbe gibt es einen wunderbar einfachen Trick. Doch dazu später mehr. Beginnen wir zunächst einmal mit einer Konstante und einer Funktion, die wir später noch benötigen:

DEFINE('CTX', stream_context_create(array(
    'http' => array(
        'timeout' => 20,
        'method' => 'get',
        'header' => 'Referer: XYZ'
    )
)));

Unsere Konstante CTX ist also ein array. Wir benötigen es für unsere HTTP-Anfrage, mit der wir das gewünschte Bild auf unseren Server laden. Für diese Anfrage verwenden wir die HTTP-GET-Methode, definieren einen Timeout von maximal 20 Sekunden und senden einen Referer im Header, den ich hier mal einfach nur “XYZ” genannt habe.

function randomstring_creator($len = 20) {
    $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $string = '';
    mt_srand((double) microtime() * 1000000);
    for($i = 0; $i < $len; $i++) {
        $string .= $chars{mt_rand(0, strlen($chars))};
    }
    return($string);
}

Die Funktion randomstring_creator() generiert uns eine zufällige Zeichenfolge mit einer beliebigen Länge. Wir benötigen diese Funktion, da wir in diesem Beispiel die Bilder lokal unter einem zufälligem Namen speichern werden.

Weiter geht es mit unseren Klassen. Beginnen wir mit der Klasse Image:

class Image {
    var $img;
    var $source;
    var $local;
    var $dimX;
    var $dimY;
    var $avg_colour;
    function get($source, $quality = 90) {
// siehe unten
    }
    function calc_avg_colour() {
// siehe unten
    }
}

Unsere Klasse besitzt also die Eigenschaften source (die Url, von der das Bild stammt), local (den lokalen Speicherpfad), dimX, dimY (die Abmessungen des Bildes in Pixel) und avg_colour (den farblichen Durchschnittswert als HEX-Code in der Form rrggbb). Die Eigenschaft img ist eine Referenz auf das Image-Objekt, dass ich aber später noch näher beleuchten werde.

Die beiden Funktionen get() und calc_avg_colour() der Klasse sollten selbsterklärend sein. Mit der Funktion get(), die gleichzeitig auch als Konstruktor dient, laden wir das Bild, dass unter source zu finden ist, auf unseren Server und speichern es in der gewünschten JPEG-Qualität (90 als Standard) lokal.

calc_avg_colour() berechnet – wie der Name schon sagt – die Durchschnittsfarbe des in der Eigenschaft img gespeicherten Bildes.

Wir wollen zusätzlich aber auch kleine Abbilder des Originalbildes erstellen und erweitern dazu unsere Image-Klasse um die Klasse Thumbnail:

class Thumbnail extends Image {
    function create($parent, $X = 300, $Y = 300, $quality = 60) {
// siehe unten
    }
}

Diese Erweiterung besitzt zunächst nur eine Funktion, mit der das Thumbnail erstellt wird. Die übergebene Variable parent enthält dabei eine bereits existierende Image-Klasse, die herunterskaliert werden soll. Die maximale Breite und Höhe werden mit den Variablen X und Y (standard bei 300 Pixel) übergeben. Die JPEG-Qualität beträgt standardmäßig nur 60.

Das eigentliche Programm sieht dann nur noch so aus:

$imgurl = 'original.jpg';
// neues Objekt der Klasse Image erzeugen
$img = new Image;
// Bild aus der imgurl laden
if($img->get($imgurl)) {
    // ein Objekt der Klasse Thumbnail erzeugen
    $thumb = new Thumbnail;
    // und ein Thumbnail des oben definierten Objektes der Klasse Image generieren
    $thumb->create($img, 300, 300);
    // dann noch die Durschschnittsfarbe berechnen
    $thumb->calc_avg_colour();
    // und Daten ausgeben... fertig
    echo('Image: ' . $img->source . "\n");
    echo('Thumbnail: ' . $thumb->source . "\n");
    echo('Average colour: #' . $thumb->avg_colour . "\n");
} else {
    echo('Could not get the image.');
}

So, dann sehen wir uns also mal unsere Funktionen der Klassen an. Beginnen wir mit der Funktion get():

function get($source, $quality = 90) {
    $this->source = $source;
    // wir laden das Bild von $source:
    if(($file = file_get_contents($this->source, false, CTX))) {
        // wenn erfolgreich, erzeugen wir mit den geladenen Daten
        // ein neues Bild und speichern dieses in der Eigenschaft img
        $this->img = imagecreatefromstring($file);
        // wir lesen die Höhe und Breite des Bildes aus
        $this->dimX = imagesx($this->img);
        $this->dimY = imagesy($this->img);
        // und speichern das Bild unter zufälligem Namen mit imagejpeg lokal im Ordner "raw"
        $this->local = 'raw/' . randomstring_creator() . '.jpg';
        imagejpeg($this->img, $this->local, $quality);
        // bei Erfolg true zurückgeben
        return(true);
    } else {
        // false, wenn das Bild nicht geladen werden konnte
        return(false);
    }
}

Ein Thumbnail erzeugen wir mit dieser Funktion der Klasse Thumbnail:

function create($parent, $X = 300, $Y = 300, $quality = 60) {
    // zunächst die vorläufigen Abmessungen speichern
    $this->dimX = $X;
    $this->dimY = $Y;
    // die Abmessungen und deren Verhältnis des Originalbildes holen
    $origX = $parent->dimX;
    $origY = $parent->dimY;
    $ratio = $origX / $origY;
    // wenn das Originalbild breiter als hoch ist, kürzen wir die Höhe
    if($X / $Y > $ratio) {
        $this->dimX = $Y * $ratio;
    } else {
    // wenn das Originalbild höher als breit ist, kürzen wir die Breite
        $this->dimY = $X / $ratio;
    }
    // hier erstellen wir ein neues Bild mit den oben berechneten Abmessungen
    $this->img = imagecreatetruecolor($this->dimX, $this->dimY);
    // und kopieren das Originalbild einfach in das eben erstellte kleinere, dabei wird es verkleinert
    imagecopyresampled($this->img, $parent->img, 0, 0, 0, 0, $this->dimX, $this->dimY, $origX, $origY);
    // jetzt speichern wir das neue Thumbnail noch unter zufälligem Namen im Ordner "thumb"
    $this->source = $parent->local;
    $this->local = 'thumb/' . randomstring_creator() . '.jpg';
    imagejpeg($this->img, $this->local, $quality);
}

Das Herzstück: Wir wollen die Durchschnittsfarbe ermitteln. Dazu könnten wir einfach alle Farbwerte aller Pixel zusammen addieren und dann durch die Anzahl der Pixel teilen. Bei einem Thumbnail von der Größe 300 x 300 Pixel, würden wir aber eine Schleife mit 90.000 Durchläufen benötigen. Es gibt einen besseren Weg – einen ganz logischen Trick.

Durchschnittsfarbe berechnen

Wir haben oben beim Erstellen des Thumbnails die Funktion imagecopyresampled() verwendet. Was wenn wir unser Thumbnail einfach auf eine Größe von 1×1 Pixel skalieren? Genau: Es bleibt ein Pixel mit der Durschnittsfarbe übrig. Dessen Farbe auszulesen ist mit imagecolorat() dann nur noch eine Kleinigkeit. Los gehts:

function calc_avg_colour() {
    // ein temporäres Bild mit den Abmessungen 1x1 Pixel erstellen
    $avrg = imagecreatetruecolor(1, 1);
    // Das Thumbnail einfach reinkopieren, dabei auf 1x1 Pixel skalieren
    imagecopyresampled($avrg, $this->img, 0, 0, 0, 0, 1, 1, $this->dimX, $this->dimY);
    // Die Farbe des verbleibenden Pixels auslesen
    $rgb = imagecolorat($avrg, 0, 0);
    // Das temporäre Bild wieder löschen
    imagedestroy($avrg);
    // Und die Farbe in HEX umwandeln
    $r = dechex($rgb >> 16);
    $g = dechex($rgb >> 8 & 255);
    $b = dechex($rgb & 255);
    if(strlen($r) < 2) $r = 0 . $r;
    if(strlen($g) < 2) $g = 0 . $g;
    if(strlen($b) < 2) $b = 0 . $b;
    // tataaaa... da ist unsere Durchschnittsfarbe:
    $this->avg_colour = $r . $g . $b;
}

Super. Das wäre es. Ende und aus.

Serverseitig den Webseitenaufbau mit DNS CNAMES und mehr parallele HTTP-Verbindungen beschleunigen

Philipp — Sat, 06 Feb 2010 13:44:43 +0000

Man stelle sich folgendes Szenario vor: Es existiert eine Webseite, die eine Vielzahl von Grafiken, die auf dem gleichem Server hinterlegt sind, einbindet. Diese Webseite wird erfahrungsgemäß eine überdurchschnittlich lange Ladezeit haben. Aber nicht nur aufgrund der zu übertragenen Datenmengen, sondern auch aufgrund der maximalen Anzahl von Verbindungen, die ein Browser auf ein und denselben Server erlaubt. Hier werde ich etwas über die Beschleunigung vom Aufbau von Webseiten schreiben. Dabei verwende ich gewisse DNS Einstellungen, so genannte CNAME-Records mit denen ich serverseitig mehrere parallele HTTP-Verbindungen erlauben kann und so das Laden der Webseite durch den Browser des Nutzers beschleunige.

Standardmäßig sind moderne Browser mit maximalen Anzahl von sechs Verbindungen (IE 6 und IE 7 maximal zwei Verbindungen) zu ein und demselben Host begrenzt. Das führt dazu, dass das Laden von Dateien (Bilder, HTML-Seiten, JavaScripts oder Stylesheets) von einer Webseite in Blöcken unterteilt wird. Dabei würde es um einiges schneller gehen können, wenn ich die zu ladenden Dateien auf verschiedene Hostnamen verteile. So können für jeden Hostnamen mehr Verbindungen gleichzeitig ermöglicht werden.

Man betrachte zum Beispiel Google Maps. Die angezeigte Karte besteht aus einer vielzahl von so genannten Tiles. Tiles sind einfach Kacheln. Jede Kachel stellt einen Kartenausschnitt dar:

Damit die Karte schnellstmöglich trotz der Browserbegrenzung von sechs Verbindungen geladen werden kann, verteilt Google Maps die zu ladenden Kacheln auf verschiedene Hostnamen (Subdomains). Google verwendet vier Subdomains: mt0, mt1, mt2 und mt3.google.de:

Grundsätzlich ist es kein großes Problem verschiedene Subdomains anzulegen und die Dateien einer Webseite auf diese Subdomains zu verteilen. Allerdings besteht so recht schnell die Gefahr, dass man als Administrator den Überblick verliert, wo welche Dateien abgespeichert sind. Einfacher wäre es, zB. alle Mediendateien (zB. Bilder, Videos) unter einer Subdomain abzuspeichern. Um das Laden der Startseite erheblich zu beschleunigen, aber ohne zahlreiche Subdomains zu arbeiten kann man wie folgt vorgehen:

Ich lege unter der Hauptdomain eine einzige subdomain namens media.domain an. Hier speichere ich alle Bilder ab.
Ich lege so genannte CNAMES Einträge in meinen DNS Einstellungen an. Ein CNAME ist – einfach erklärt – ein Domain-Alias. In meinem Fall wähle ich zwei CNAME-Einträge namens “media0.domain.de” und “media1.domain.de” an. Am einfachsten geht es über die Adminoberfläche Plesk und sieht folgendermaße aus:
Diese beiden Einträge bewirken, dass media0.domain.de und media1.domain.de auf die gleiche subdomain media.domain.de umleiten. Ich habe jetzt also eine Subdomain, die auf drei unterschiedliche Weisen erreicht werden kann. Der Browser des Nutzers interpretiert die drei Domains als drei unterschiedliche Adressen, die aber auf den gleichen Speicherort verweisen. So sind drei mal so viele Verbindungen zum eigentlich gleichen Host möglich. Der Browser wird einfach ausgetrickst.
Bei der Einbindung der Bilder in die Webseite muss ich jetzt nur die zwei verschiedenen “subdomains” media0 und media1 verteilen. Ich löse das über einen Zufallsgenerator in meinem PHP Script, dass den HTML-Code generiert. Dieser könnte zB. so aussehen:

$media_domains = array('media0', 'media1');
foreach($bilder as $bild) {
  shuffle($media_domains);
  echo('');
}

Und fertig. Kommentare, Verbesserungsvorschlage? Dazu sind die Kommentare da.