Google hat mit AdSense die Möglichkeit Anzeigen direkt am Content und wahrscheinlich auch benutzerdefiniert zu setzen. Affiliate-Anzeigen werden dagegen oft auf der ganzen Seite oder in / unter einzelnen Artikeln gezeigt.

Ich habe mir allerdings eine Methode ausgedacht, mit welcher sich die Affiliate Einnahmen erhöhen lassen: Man wählt die anzuzeigende Anzeige durch den Referrer aus.

Ist keine passende Anzeige vorhanden wird AdSense angezeigt.

Welche Arten von Referrers werden ausgewertet?

Hoch interessant sind an der Stelle natürlich Besucher, die über Suchmaschinen kommen. Bei denen kann man sofort wissen, wonach sie gesucht haben und was sie auf der Seite erwarten.

Bei Refferers (ohne Suchmaschinen) die viele Besucher bringen kann man auch gezielt Affiliate Anzeigen schalten. Dabei sollte die Auswahl jedoch nach Möglichkeit nicht über die komplette Domain, sondern über einzelne Seiten gewählt werden. Denn eine Domain kann schließlich auf verschiedene nicht zusammenhängende Inhalte verlinken.

Findet man bei den beideren oberen Auswahlverfahren keinen passenden Affiliate kann man den Referrer nach bestimmten Texten durchsuchen. So kann man zum Beispiel zu allen Referrers, wo “SEO” drin steht irgendwelche SEO-Tools promoten.

Affilates finden

Um Affiliate-Anzeigen anzuzeigen muss man natürlich auch passende Partner finden. Dabei gibt es einen einfachen Trick. Wenn Leute über Suchmaschinen zu euch gelangen, könnt ihr einfach deren Suchanfrage selbst bei Google eintippen und die AdWords anzeigen Analysieren. Nun schaut ihr euch die Seiten an und sucht dort nach Affiliate Möglichkeiten.

Eine weitere Variante ist, dass ihr Affiliate-Netzwerke nach diesen Keywords durchsucht. Dort werdet ihr bestimmt einen passenden Partner finden.

Sollte das auch kein Ergebnis liefern, kann man sich Allround-Anbieter wie zum Beispiel Amazon oder Ebay heraussuchen und dort nach passenden Produkten suchen.

Quellcode

Das klingt ja in der Theorie alles ganz toll, aber die Umsetzung ist etwas komplizierter. Aus diesem Grund habe ich mal ein bisschen PHP-Code für euch vorbereitet. Dieser ist noch ziemlich einfach gehalten. Auf großen Seiten sollte man das ganze über eine Datenbank abhandeln.

Die einzelnen Quellcode Abschnitte können später aneinander gehängt werden und ergeben ein kleines Anzeige-Management Tool.

Fangen wir an mit der Initialisierung. In der Variable $anzeige wird der Code für die anzuzeigende Anzeige erstellt. Diese beinhaltet standardmäßig AdSense Code (Könnt ruhig meinen drinbehalten ):

<?PHP
  $referrer = 'http://www.google.de/search?q=vserver+kostenlos&rlz=1I7GZAZ_de';
  //$referrer = $_SERVER["HTTP_REFERER"];
  $anzeige  = '<script type="text/javascript"><!--
google_ad_client = "pub-9422021339860562";
                 /* 468x60, Erstellt 03.12.09 */
google_ad_slot = "6995978195";
google_ad_width = 468;
google_ad_height = 60;
                 //-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script>';
?>

In dem Referrer habe ich nun fest eine Google-Url hereingeschrieben. Im produktiven Einsatz müsstet ihr diese Zeile entfernen und die auskommentiere Zeile wieder einkommentieren.

Nun fragen wir als erstes eine komplette Seiten-Url ab. Die Reihenfolge der If-Abfragen könnt ihr gerne beliebig verändern. Für meinen Test nehme ich nun eine Seite von T3n, die mir in letzter Zeit einige Besucher gebracht hat. T3n hat an der Stelle einen Link zu meinem kleinsten Blog System der Welt gesetzt. Über diese Url könnten zum einen Blogger und zum anderen Programmierer zur Seite kommen. Da ich vermute, dass die meisten davon Männer sind, hab ich mir gedacht, dass ein Banner mit nem schönen Mädel bestimmt ein paar Leads bringen kann. Dann blende ich mal eine FlirtCafe Werbung ein:

  if($referrer == 'http://t3n.de/news/t3n-linktipps-amazon-blippy-nokia-n900-test-wordpress-266635/'){
    $anzeige = '<!-- BEGIN PARTNER PROGRAM - DO NOT CHANGE THE PARAMETERS OF THE HYPERLINK -->
<a href="http://partners.webmasterplan.com/click.asp?ref=292575&site=5682&type=b18&bnb=18" target="_blank">
<img src="http://banners.webmasterplan.com/view.asp?ref=292575&site=5682&b=18" border="0" alt="Flirtcafe" width="468" height="60" /></a><br />
                <!-- END PARTNER PROGRAM -->';
  }

Nun ja, in unserem Beispiel wurde aber nach kostenlosen V-Servern gesucht. Kostenlose VServer wird man bei Affiliates wahrscheinlich nicht finden. Dann zeigen wir eben kostengünstige an. So zum Beispiel von HostEurope:

  else if(strpos($referrer,'q=vserver+kostenlos') >= 0){
    $anzeige = '<!-- BEGIN PARTNER PROGRAM - DO NOT CHANGE THE PARAMETERS OF THE HYPERLINK -->
<a href="http://partners.webmasterplan.com/click.asp?ref=292575&site=1719&type=b4&bnb=4" target="_blank">
<img src="http://banners.webmasterplan.com/view.asp?ref=292575&site=1719&b=4" border="0" alt="Virtual Server 3.0" width="468" height="60" /></a><br />
                <!-- END PARTNER PROGRAM -->';
  }

Mit dem Parameter q werden in den meisten Suchmaschinen die Keywords angegeben. Hier müssen wir nun einfach unser vserver kostenlos eingeben und testen, ob die Position >= 0 ist. Das vserver kostenlos ist im Referrer natürlich codiert. Die einfachste Variante ist, das Keyword in einer Suchmaschine einzugeben und sich den Parameter aus der Url zu ziehen.

Auf die gleiche Weise können wir auch den Referrer ohne das q= durchsuchen. Das sieht dann zum Beispiel so aus:

<?php
  else if(strpos($referrer,'vserver+kostenlos') >= 0){
    $anzeige = '<!-- BEGIN PARTNER PROGRAM - DO NOT CHANGE THE PARAMETERS OF THE HYPERLINK -->
<a href="http://partners.webmasterplan.com/click.asp?ref=292575&site=1719&type=b4&bnb=4" target="_blank">
<img src="http://banners.webmasterplan.com/view.asp?ref=292575&site=1719&b=4" border="0" alt="Virtual Server 3.0" width="468" height="60" /></a><br />
                <!-- END PARTNER PROGRAM -->';
  }

In diesem Fall könnten wir uns die Abfrage für die Suchmaschine sparen, aber das ist ja auch nur ein Beispiel.
Zum Schluss muss natürlich die Anzeige ausgegeben werden. Das geht dann so:

  echo $anzeige;
?>

Erweiterungen

Natürlich kann man zu dem Verfahren auch noch seitenbasierende Anzeigen einbringen. Außerdem ist es eine Überlegung, für bestimmte Seiten auch nur bestimmte Affiliate-Anzeigen zu testen. Bei vielen Anzeigen wird die Seite dadurch schneller.

Desweiteren könnte man den Referrer in der Session speichern, weil wenn der Besucher eine weitere Seite aufruft, wird der neue Referrer von der eigenen Seite sein.

Fazit

Durch dieses Verfahren kann man seine Affiliate Einnahmen stark erhöhen. Wie stark genau hängt natürlich immer vom Partner und vom Thema ab.

Nun loggt euch mal alle in euren Admin-Bereich ein und schaut euch die MySQL-Fehler dort an. Was fällt euch auf?

Also mir ist dabei zuerst aufgefallen, dass ich mein Passwort immer wieder falsch eingegeben habe. Das war natürlich nicht so. In der Klasse /system/classes/user.php wurde noch mit der alten $dbprefixgearbeitet, die nicht mehr gültig ist.  Hier ist der neue Code für die Methode checkPassword:

<?php
  function checkPassword($password){
    $password =$GLOBALS['db']->EscapeString(trim($password));
    $name = $GLOBALS['db']->EscapeString(trim($this->name));
    $count = $GLOBALS['db']->ReadField("SELECT COUNT(*) FROM {'dbprefix'}user WHERE 
                        name='".$name."' AND password = '".md5($password)."'");
    return $count == 1;
  }
?>

Nun könnt ihr euch anmelden. Nun bekommt ihr mit Sicherheit wieder eine Reihe an mysql-Fehlern. Diese werden in diesem Artikel behoben.

Los geht’s mit der Klasse /system/classes/menu.php. Hier wurden die auf der Startseite des Admin-Bereichs benötigten Methoden passend zur Datenbankklasse umgebaut:

<?PHP
class Menu{
  function display($id, $globalstart,$globalend, $elementstart,$elementend,$class){
    $rows = $GLOBALS['db']->ReadRows("SELECT title,href FROM {'dbprefix'}menu WHERE menuID = '".$id."' ORDER BY id");
    echo $globalstart;
    $i = 1;
    foreach($rows as $row){
      echo $elementstart."<a href=\"".$row->href."\"title=\"".$row->title."\" 
           class=\"".$class." menue-".$id."-".$i."\">".$row->title."</a>".$elementend;
      $i++;
    }
    echo $globalend;
  }
  
  function getIdByName($name){
    $name = $GLOBALS['db']->EscapeString(strtolower(trim($name)));
    return $GLOBALS['db']->ReadField("SELECT id FROM {'dbprefix'}menu_names WHERE lower(trim(name)) = '".$name."' LIMIT 0,1");;
  }

  function displayEditable($id){
    $res = mysql_query("SELECT id, title,href FROM ".$dbpraefix."menu WHERE menuID = '".$id."' ORDER BY id");
    while($row = mysql_fetch_row($res)){
      echo $elementstart."<input name=\"".$row[0]."_title\"value=\"".$row[1]."\" />
                          <input name=\"".$row[0]."_href\"value=\"".$row[2]."\" />
                          <input type=\"submit\"name=\"".$row[0]."_delete\"value=\"X\"/><br />";
    }
  }

  function addEntry($menu,$title,$href){
    global $dbpraefix;
    $res = mysql_query("SELECT MAX(id) FROM ".$dbpraefix."menu 
                        WHERE menuID = '".$menu."'");
    $row = mysql_fetch_row($res);
    $id = $row[0] + 1;
    $res = mysql_query("INSERT INTO ".$dbpraefix."menu (id,menuID,title,href)
                        VALUES('".$id."','".$menu."',
                               '".$title."','".$href."')");
    if($res){
      $args['menu']  = $menu;
      $args['title'] = $title;
      $args['href']  = $href;
      EventManager::raiseEvent("menu_entry_added","../",$args);
    }
    return $res;
  }

  function editEntry($menu,$id,$title,$href){
    global $dbpraefix;
    $res =  mysql_query("UPDATE ".$dbpraefix."menu SET 
                          href = '".$href."', 
                          title = '".$title."' 
                        WHERE id = '".$id."' 
                          AND menuID = '".$menu."'");
    if($res){
      $args['menu']  = $menu;
      $args['title'] = $title;
      $args['href']  = $href;
      $args['id']    = $href;
      EventManager::raiseEvent("menu_entry_edit","../",$args);
    }
    return $res;
  }

  function deleteEntry($menu,$id){
    global $dbpraefix;
    $res = mysql_query("DELETE FROM ".$dbpraefix."menu WHERE menuID = '".$menu."' AND id = '".$id."'");
    if($res){
      $res = mysql_query("UPDATE ".$dbpraefix."menu SET id = id - 1 WHERE id > '".$id."'");
      if($res){
        $args['menu']  = $menu;
        $args['id'] = $id;
        EventManager::raiseEvent("menu_entry_deleted","../",$args);
      }
    }
    return $res;
  }

  function create($name){
    global $dbpraefix;
    $res = mysql_query("INSERT INTO ".$dbpraefix."menu_names (name) VALUES ('".$name."')");
    if($res){
      $args['name']  = $name;
      EventManager::raiseEvent("menu_created","../",$args);
    }
    return mysql_insert_id();
  }

  function delete($id){
    global $dbpraefix;
    $res = mysql_query("DELETE FROM ".$dbpraefix."menu_names WHERE id = '".$id."'");
    if($res){
      $res = mysql_query("DELETE FROM ".$dbpraefix."menu WHERE menuID = '".$id."'");
      if($res){
        $args['id']  = $id;
        EventManager::raiseEvent("menu_deleted","../",$args);
      }
    }
    return $res;
  }
}
?>

Gleiches bei /system/classes/dashboard.php:

<?PHP
  class Dashboard{
    public $id;
    public $cols;
    
    function loadWidgets(){
      $this->cols[] = $this->loadWidgetsByColumn(1);
      $this->cols[] = $this->loadWidgetsByColumn(2);
      $this->cols[] = $this->loadWidgetsByColumn(3);  
    }
    
    function loadWidgetsByColumn($columnId){
      $columnId = $GLOBALS['db']->EscapeString($columnId);
      $rows = $GLOBALS['db']->ReadRows("SELECT path FROM {'dbprefix'}dashboards 
                                        WHERE col = '".$columnId."' AND id = '".$this->id."'
                                           ORDER BY row");
      if($rows){
        foreach($rows as $row){
          $widgetData =WidgetController::getWidgetData($row->path);
          $widget =WidgetController::getWidget($widgetData);
          $widget->load();
          $res[] = $widget;
        }
      }
      
      return $res;
    }
    
    function display(){
      echo "<div id=\"columns\">";
      $this->displayColumn(0);
      $this->displayColumn(1);
      $this->displayColumn(2);
      ?>
        <script type="text/javascript" src="http://jqueryjs.googlecode.com/files/jquery-1.2.6.min.js"></script>
        <script type="text/javascript" src="jquery-ui-personalized-1.6rc2.min.js"></script>
        <script type="text/javascript" src="inettuts.js"></script>
      <?PHP
    }
    
    function displayColumn($id){
      ?>
        <ul id="column<?PHP echo $id; ?>" class="column">
          <?PHP
            if($this->cols[$id]){
              foreach($this->cols[$id] as $widget){
                $widget->display();
              }
            }
          ?>
        </ul>
      <?PHP
    }
  }
?>

Fangen wir an mit mysqli. Leider hatte ich mich zuvor noch nicht damit beschäftigt, so dass ich die Klasse /system/classes/mysql.php erst einmal auf dem veralteten MySQL-Zugriff ansteuerte. Heute gibts das Update auf mysqli. Evtl. werde ich in Kürze einen oder auch mehrere Beiträge  (außerhalb der CMS Aktion) über MySQLi veröffentlichen.

Nun gehts aber zur Klasse. MySQLi ist objektorientiert. Die Änderungen die ich gemacht habe werde ich an dieser Stelle nicht weiter erläutern. Wenn das MySQLi Tutorial fertig ist, setz ich an dieser Stelle einen Link dazu.

Hier ist der Code:

<?PHP
  class MySQL extends DataBase{
    private $connection;

    public function Execute($sql){
      return $this->connection->query(str_replace("{'dbprefix'}",$this->Prefix,$sql));
    } 
    
    public function GetTables(){
      $res =  $this->connection->query("SHOW TABLES");
      while($row = $res->fetch_row()){
        $tables[] = $row[0];
      }
      sort($tables);
      return $tables;
    }
      
    public function GetColumns($table){
      $mysqlres = $this->Execute("SHOW COLUMNS FROM ".$table);
      while($row = $mysqlres->fetch_object()){
        $res[] = $row;
      }
      return $res;
    }
      
    public function ReadField($sql){
      $res = $this->Execute($sql);
      $row = $res->fetch_row();
      return $row[0];
    }
      
    public function ReadRow($sql){
      $res = $this->Execute($sql);
      return $res->fetch_object();
    }
      
    public function ReadRows($sql){
      $mysqlRes = $this->Execute($sql);
      while($row = $mysqlRes->fetch_object()){
        $res[] = $row;
      }
      return $res;
    }
    
    public function EscapeString($text){
      return $this->connection->real_escape_string($text);
    }
      
    public function Connect(){
      $this->connection = new mysqli($this->Host,$this->User,$this->Password,$this->Name);
    }
      
    public function Disconnect(){
      $this->connection->close();
    }
  }
?>

Nun kommen wir zum “schlimmen” Teil für heute: Bitte löscht die Datei /system/dbconnect.php!

Wenn ihr nun eure Startseite besucht, bekommt ihr wahrscheinlich ein paar schöne Fehlermeldungen. Da mein Testsystem online ist habe ich dort den PHP-Code auskommentiert und eine Fehlermeldung erstellt:

<html>
  <head>
    <title>Vorschau nicht verfügbar</title>
  </head>
  <body>
    <h1>Vorschau zur Zeit nicht verfügbar</h1>
    <p>Durch die Derzeitigen Arbeiten an der Datenbank des CMS<br />
       ist die Vorschau zur Zeit nicht verfügbar.</p>
    <p>Keine Angst, dass schafst Du auch ohne!<br />
       Wenn nicht wird dir im <a href='http://forum.stevieswebsite.de/'>Forum</a> geholfen.</p>
  </body>
</html>
<?PHP
/*
  function __autoload($class_name){
      require_once "system/classes/".strtolower($class_name).".php";
  }
  include("system/settings.php");
  include("system/filterfilename.php");
  include("system/sys.php");
  $currentpage = new Page();
  $currentpage->loadProperties(mysql_real_escape_string($_GET['include']));
  if(!$_GET['skin']){
    include(SkinController::getCurrentSkinPath()."/index.php");
  }
  else{
    include('system/skins/'.$_GET['skin']."/index.php");
  }
  */
?>

Mit der Umstellung fangen wir nämllich im Admin-Bereich an. Dort können wir ruhig Fehlermeldungen haben, die Besucher so nicht sehen werden. Mit den ersten Änderungen fangen wir jetzt an, damit auch beim Login nichts zu sehen ist.

Zunächst muss der include für die dbconnect.php entfernt werden. Zum anderen muss die Verbindung zur Datenank aufgebaut werden. Das geht so (/admin/index.php):

<?PHP
  session_start();
  function __autoload($class_name){
      require_once "../system/classes/".strtolower($class_name).".php";
  }
  include("../system/settings.php");
  include("../system/filterfilename.php");
  include("../system/sys.php");
  $db = new MySQL('../system/dbsettings.php');
  $db->Connect();
?>

Weiter gehts mit der Klasse /system/classes/customcss.php. Hier wird die Methode getStylePath umgestellt:

    function getStylePath($id){
      $id = $GLOBALS['db']->EscapeString($id);
      return $GLOBALS['db']->ReadField("SELECT stylePath FROM {'dbprefix'}custom_css
                                        WHERE id = '".$id."'");
    }

Hier seht ihr auch schon die Vorteile der Klasse: Für das Select brauchen wir nur noch eine einzige Zeile!

Da man auch als Nicht-Admin versuchen kann sich einzuloggen müssen wir auch die Klasse /system/classes/user.php bearbeiten:

<?PHP
class User{
  var $name;

  function login($name,$password){
    global $dbpraefix;
    $password = $GLOBALS['db']->EscapeString(trim($password));
    $this->name = $GLOBALS['db']->EscapeString(trim($name));
    if($this->checkPassword($password)){
      return true;
    }
    else{
      return false;
    }
  }

  function checkPassword($password){
    global $dbpraefix;
    $password =$GLOBALS['db']->EscapeString(trim($password));
    $name = $GLOBALS['db']->EscapeString(trim($this->name));
    $count = $GLOBALS['db']->ReadField("SELECT COUNT(*) FROM ".$dbpraefix."user WHERE 
                        name='".$name."' AND password = '".md5($password)."'");
    return $count == 1;
  }
  
  function logout(){
     session_destroy();
  }
}
?>

Das wars auch schon für heute. Wie oben beschrieben werden wir uns als nächstes den Admin-Bereich vorknüpfen. Dieser wird dann auf das neue DB-System umgestellt. Wenn der fertig ist gehen wir systematisch alle Dateien durch und suchen veraltete mysql-Zugriffe. Danach kann dann der Besucher-Bereich wieder online gehen.

An dieser Stelle muss ich mich natürlich bei allen bedanken, die immer fleißig Kommentare geschrieben haben. Ihr seit die besten!

Viel interessanter ist es aber bei den Backlinks. Insgesamt wurde über SteviesWebsite.com in 8 anderen Blogs berichtet. Außerdem gibt es noch einen Link vom spanischen Softonic. Die Berichte über die Seite bzw. deren Artikel sind in bisher 5 verschiedenen Sprachen (Deutsch, English, Spanisch, Rumänisch & Russisch).

Von den Besuchern her sieht es noch nicht ganz so gut aus. Insgesamt konnte ich 232 Besucher verzeichnen, da bekommt das deutsche SteviesWebsite noch mehr an einem Tag XD

Aber interessant ist das Karten Overlay:

Kartenoverlay SteviesWebsite.com

Im großen und ganzen finde ich den Einstieg in die internationale Blogsphere trotz noch rel. weniger Besucher gelungen. Ich werde dort in Kürze auch öfters bloggen.

Im Dezember habe ich ein ähnliches Verfahren über Google Webmaster Tools vorgestellt. Für die Methode mit Google Analytics müsst ihr allerdings etwas mehr Zeit investieren.

Um die Methode durchzuführen benötigst Du ein Datenbanksystem. Dadurch ist es möglich mit den Keywords “rumzuspielen”.

Ich habe mit 2 Tabellen angefangen:

• pages: Beinhaltet die Url der Seiten
• keywords: Beinhaltet Position und Anzahl der Besucher der Keywords

Die Create-Statements sehen folgendermaßen aus:

CREATE TABLE pages(
    [id] [int] IDENTITY(1,1) NOT NULL,
    [url] [nvarchar](255) COLLATE Latin1_General_CI_AS NULL,
 CONSTRAINT [PK_pages] PRIMARY KEY CLUSTERED
(
    [id] ASC
)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]

CREATE TABLE [dbo].[keywords](
    [page] [int] NULL,
    [keyword] [nvarchar](255) COLLATE Latin1_General_CI_AS NULL,
    [visitors] [nvarchar](255) COLLATE Latin1_General_CI_AS NULL,
    [rank] [int] NULL,
    [lastvisit] [smalldatetime] NULL
) ON [PRIMARY]

Diese SQL-Statements gelten für den SQL-Server. Sie können für andere Datenbanksysteme leicht abweichen.

Keyword Abfrage in Analytics

Nun kommen wir zu Analytics. Da wir für die Keywords einzelne Seiten und nicht die ganze Website optimieren wollen, müssen wir uns auch die Top Keywords zur jeweiligen Seite heraussuchen. Dazu benötigen wir als erstes die Top-Websiten. Diese sieht man unter Content->Top Webseiten. Ich selbst habe erst mal nur die Top 10 Seiten analysiert.

Nun musst Du auf die Top-Seite klicken und du kommst zum Beispiel zu folgender Übersicht:

Analytics Content-Details

An dieser Stelle legst Du in der Tabelle pages einen neuen Eintrag mit der Url der jeweiligen Top-Seite an.

Um nun zu den Keywords der Seite zu kommen musst Du auf “Einstiegs-Keywords” klicken. Dann kommt zum Beispiel sowas dabei heraus:

Analytics Einstiegs Keywords

Keywords eintragen

Als nächstes trägst Du erst mal die Top 15 Keywords mit der Anzahl der Besucher in deine keywords-Tabelle ein. Schreibe in die lastvisit-Spalte das aktuelle Datum. In die Spalte page kommt die id der Zeile, der pages Tabelle.

Nun gib das jeweilige Keyword bei Google ein und trage die Platz deiner Seite in die Spalte rank ein. Sollte ein Keyword nicht unter den Top 50 Keywords sein, trage dort eine -1 ein.

Das Keyword Eintragen dauert seine Zeit. Ich habe ca. 2 Stunden für 10 Seiten mit 15 Keywords gebraucht.

Auswertung

Jetzt kommt der Teil auf den Du gewartet hast! Mit dem folgenden Select-Statement bekommst ein Ranking der Keywords, auf die Du optimieren solltest:

SELECT keyword, rank, rank * rank * visitors FROM keywords WHERE rank > 1 ORDER BY rank * rank * visitors DESC

Vorteile des Verfahrens

Natürlich kann man auch durch die Webmaster Tools der Suchmaschinen zu optimierende Keywords herausfinden. Doch die Keywords in Analytics zeigen wirklich für welche Seiten sich die Besucher überhaupt interessieren (also wo Besucher auch geklickt haben). Was bringt es auf Platz 1 im Ranking zu sein, ohne das das Thema den Besucher interessiert?

Desweiteren wird nicht nur eine Suchmaschine berücksichtigt sondern alle.

Und genau damit fangen wir an. Wie im letzt en Beitrag geschrieben, hatte ich die abstrakte Klasse noch nicht gestet -> Ich hatte ja schließlich keine MySQL Klasse.

Da ich in der geerbten Klasse nicht auf private Vatiablen der Superklasse zugreifen kann, musste ich diese auf Public setzen. Das ist auch nicht weiter schlimm, denn Plugins & Co können sich die Daten so oder so aus der Config Datei ziehen.

Der neue Code der /system/classes/database.php sieht so aus:

<?PHP
  abstract class DataBase{
  
      public $Name     = '';
      public $Prefix   = '';
      public $User     = '';
      public $Password = '';
      public $Host     = '';
      public $Type     = '';
      
      public abstract function Execute($sql);
      public abstract function GetTables();
      public abstract function GetColumns($table);
      public abstract function ReadField($sql);
      public abstract function ReadRow($sql);
      public abstract function ReadRows($sql);
      public abstract function Connect();
      public abstract function Disconnect();
      
      public function __construct($config){
        include($config);
        $this->Prefix   = $dbpraefix;
        $this->Host     = $dbhost;
        $this->Password = $dbpassword;
        $this->User     = $dbuser;
        $this->Name     = $db;
        $this->Connect();
      }
  
  }
?>

Kommen wir zur Klasse MySQL. Dort werden die abstrakten Methoden umgesetzt. Die Verbindung wird in der privaten Variable $connection gespeichert. Der Tabellenprefix wird nun immer über {‘dbprefix’} angegeben. Dieser wird automatisch in den Datenbankklassen ersetzt. Das hat den Vorteil, das wir nicht immer mit global $dbprefix arbeiten müssen.

Eine weitere Neuerung in unseren Datenbankabfragen ist, dass wir aus der Klasse nur noch Objekte zurückgeben.

Die neue Datenbankklasse liegt in /system/classes/mysql.php und hat den folgenden Quellcode:

<?PHP
  class MySQL extends DataBase{
    private $connection;

    public function Execute($sql){
      return mysql_query(str_replace("{'dbprefix'}",$this->Prefix,$sql));
    } 
    
    public function GetTables(){
      $res = mysql_query("SHOW TABLES");
        while($row = mysql_fetch_row($res)){
          $tables[] = $row[0];
        }
        sort($tables);
      return $tables;
    }
      
    public function GetColumns($table){
      $mysqlres = $this->Execute("SHOW COLUMNS FROM ".$table);
      while($row = mysql_fetch_object($mysqlres)){
        $res[] = $row;
      }
      return $res;
    }
      
    public function ReadField($sql){
      $res = $this->Execute($sql);
      $row = mysql_fetch_row($res);
      return $row[0];
    }
      
    public function ReadRow($sql){
      $res = $this->Execute($sql);
      return mysql_fetch_object($res);
    }
      
    public function ReadRows($sql){
      $mysqlRes = $this->Execute($sql);
      while($row = mysql_fetch_object($mysqlRes)){
        $res[] = $row;
      }
      return $res;
    }
      
    public function Connect(){
      $this->connection = mysql_connect($this->Host,$this->User,$this->Password);
      mysql_select_db($this->Name,$this->connection);
    }
      
    public function Disconnect(){
      mysql_close($this->connection);
    }
  }
?>

Der nächste Schritt wird der wohl brutalste Schritt, den wir bisher gemacht haben. Wir werden nämlich als nächstes die alte Datenbankverbindung entfernen. Dann wird das CMS erst mal überhaupt nicht funktionieren. Nach und nach werden wir dann die Klassen und Dateien auf das neue Datennbankmodell umstellen.

Viele Blogger denken, dass sie mit verkürzten Feeds mehr Besucher auf die eigene Seite bekommen als mit Fullfeeds. Ich bin eher anderer Meinung, aber das kann muss jeder für sich selbst herausfinden. Dies und noch mehr kann man mit dem Tool Feedburner analysieren. 

Ihr müsst um Feedburner zu nutzen dort euren Feed anlegen. Dann bekommt ihr eine Url, welche ihr euren Usern als Feed anbieten könnt. Dieser Feed beinhaltet Tracking-Code, so dass Statistiken gespeichert werden können. Bei Wordpress kann man auch alle Feedleser zum Feedburner weiterleiten. Dies geht über das Plugin FeedBurner FeedSmith. 

Um die erweiterte Analyse freizuschalten geht ihr auf Analyse und dann auf TotalStats. Hier bekommt ihr folgendes zu sehen: 

Feedburner TotalStats

Normalerweise sind diese Dienste nur in der Pro-Version verfügbar, bei mir konnte ich nach einiger Zeit auch ohne Pro-Version darauf zugreifen. 

Wenn ihr nun nach ein paar Tage / Wochen erste Zahlen erfasst habt geht es an die Auswertung. Dort kann man zum Beispiel folgendes machen: 

Element Nutzung

Diese Statistik gibt die Views und Clicks der einzelnen Artikel wieder. Das ist meiner Meinung nach ein interessantes Mittel, um die eben besprochene Problemetik bzgl. Fullfeed zu testen. Bei mir sieht das zur Zeit so aus: 

Feedburner Element Nutzung

Eine schöne Verbesserung an der Stelle wäre eine Sortierungsmöglichkeit und die Klickrate. Aber auch so sind die Statistiken sehr interessant. 

Abonennten

Über die Abonennten kann man sehen, mit welchen Feedreadern die Feeds abonniert sind. Einen wirklichen Nutzen sehe ich darin aber eher nicht. Bei mir ist der Google Reader auf Platz 1: 

Feedburner Abonennten

Map Overlay

Feedburner Map Overlay

Hier sind man ähnlich wie in Analytics, woher die Leser kommen. Leider kann man an dieser Stelle jedoch nur die Länder sehen. 

Fazit 

Durch die Analyse und anschließender Optimierung des Feeds kann man seine Abonnenenten gezielt dazu bringe, die Website zu besuchen. Alle Feedleser sind quasi Stammkunden. Um diese solltet ihr euch gut kümmern!

ContentLion – The King Of Content

Dann können wir ja bald königlich an der Datenbank Klasse arbeiten

Ab jetzt werden alle Sachen, die irgendwas mit Datenbanken zu tun haben (mysql_query, mysql_fetch_row) in dieser Klasse abgebildet. Die Datenbankklasse ist allerdings abstrakt. Es wird die erbende Klasse MySQL geben, die zum Beispiel alle MySQL-Sachen regelt. Das System hat folgende Vorteile:

• Wir können die Datenbankpräfix automatisiert einfügen
• Wir können später ohne große Probleme auch Datenbanken wie SQLite oder den Sql Server unterstützen
• Wir können Datenbankfehler an einer Stelle abhandeln und zum Beispiel dem Admin eine Mail schicken
• Wir können uns in der Klasse automatisiert gegen Sql Injektions schützen (mysql_real_escape_string)
• …

Wir müssen diese Änderung sofort durchführen, da es später noch schwieriger wird das ganze umzusetzen. Im Kern des CMS werden alleine einige Erweiterungen hinzukommen, die wir sonst ersetzten müssten. Von Plugins mal ganz abgesehen.

Genug geredet, jetzt kommt der Quellcode. Johann hat mir schon ein paar Vorschläge für die Umsetzung der Klasse gemacht, die ich noch geschickt erweitert habe. Vielleicht habt ihr es schon vergessen: Wir haben bereits eine Datenbankklasse (siehe /system/classes/mysql.php). Diese ist hauptsächlich für unseren derzeit pausierenden DB-Manager zuständig. Einige Methoden habe ich in die abstrakte Klasse übernommen, andere ausgelassen (system/classes/database.php):

<?PHP
  abstract class DataBase{
  
      public $Name      = '';
  
      private $prefix   = '';
      private $server   = '';
      private $user     = '';
      private $password = '';
      private $host     = '';
      
      public abstract function Execute($sql);
      public abstract function GetTables();
      public abstract function GetColumns($table);
      public abstract function ReadField($sql);
      public abstract function ReadRow($sql);
      public abstract function ReadRows($sql);
      public abstract function Connect();
      public abstract function Disconnect();
      
      public __construct($config){
        include($config);
        $this->prefix   = $dbpraefix;
        $this->host     = $dbhost;
        $this->password = $dbpassword;
        $this->user     = $dbuser;
        $this->Name     = $db;
        $this->Connect();
      }
  
  }
?>

Als Entschädigung für die bevorstehende Arbeit habe ich euch einen neuen Einstiegpunkt gemacht:

http://blog.stevieswebsite.de/download/132.zip

Wenn ihr Probleme mit ContentLion habt meldet euch am besten im Forum.