Die Aufgabe auf der Serverseite besteht normalerweise darin, logische Operationen gemäß der Anforderung des Clients auszuführen und die Ergebnisantwort zurückzugeben. Diese Antwort liegt normalerweise im XML-Format vor (daher muss die Serverseite das DOM von PHP verwenden, um eine XML-Antwort zu erstellen).
1. PHP verwendet DOM, um eine XML-Antwort zu erstellen, die vom JS des Clients analysiert und dann auf der Seite angezeigt wird Sie müssen mit der DOM-API von PHP vertraut sein)
Tatsächlich gibt es zwei Möglichkeiten, XML in PHP zu generieren:
Verwenden Sie die DOM-API (Methode 1).
Die andere besteht darin, den XML-Inhalt direkt wiederzugeben (Methode 2).
Siehe Beispiel:
HTML-Seite (enthält drei JS-Triggerfunktionen: onmouseover, onmouseout, onclick; lösen jeweils ihre eigenen Funktionen aus)
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//en">
<html>
<Kopf>
<title> Server PHP Ajax </title>
<script type="text/javascript" src="js.js"></script>
</head>
<body>
<span onmouseover="PHPechoXML()" onmouseout="PHPDOMXML()">Standardwörter</span>
<div id="show"></div>
dividiere<input type="text" id="firstNumber"/>durch
<input type="text" id="secondNumber"/>
<input type="button" value="Send" onclick="CSparameter()"/>
<div id="result"></div>
</body>
</html>
JS-Seite (definieren Sie jeweils drei JS-Triggerfunktionen: PHPechoXML, PHPDOMXML und CSparameter)
Es gibt Funktionen zur Erstellung von XMLHttpRequest-Objekten und entsprechende Funktionen zur Verarbeitung von Serverantworten.
///////1. XMLHttpRequest-Objekt erstellen
var xmlHttp = createXmlHttpRequestObject();
function createXmlHttpRequestObject()
...{
var xmlHttp;
versuchen
...{
// versuchen, ein XMLHttpRequest-Objekt zu erstellen
xmlHttp = new XMLHttpRequest();
}
fangen(e)
...{
// gehe von IE6 oder älter aus
var XmlHttpVersions = new Array('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
for (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
versuchen
...{
// versuchen, ein XMLHttpRequest-Objekt zu erstellen
xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
}
fangen (e) ...{}
}
}
if (!xmlHttp)
Alert("Fehler beim Erstellen des XMLHttpRequest-Objekts.");
anders
return xmlHttp;
}
///////2. JavaScript-Ereignisantwortfunktion (Onmouseover-Trigger)
// eine Datei vom Server lesen
Funktion PHPichoXML()
...{
// nur fortfahren, wenn xmlHttp nicht ungültig ist
if(xmlHttp)
...{
// versuche, eine Verbindung zum Server herzustellen
versuchen
...{
//Initiieren Sie das Lesen einer Datei vom Server
//Sende eine asynchrone Anfrage an die Datei PHPechoXML.php auf der Serverseite
xmlHttp.open("GET", "PHPechoXML.php", true);
xmlHttp.onreadystatechange = handleRequestStateChange;
xmlHttp.send(null);
}
// im Fehlerfall den Fehler anzeigen
fangen (e)
...{
alarm("Verbindung zum Server nicht möglich: " + e.toString());
}
}
}
///////3. JavaScript-Ereignisantwortfunktion (Onmouseout-Trigger)
FunktionPHPDOMXML()
...{
// nur fortfahren, wenn xmlHttp nicht ungültig ist
if(xmlHttp)
...{
// versuche, eine Verbindung zum Server herzustellen
versuchen
...{
//Initiieren Sie das Lesen einer Datei vom Server
//Sende eine asynchrone Anfrage an die Datei PHPDOMXML.php auf der Serverseite
xmlHttp.open("GET", "PHPDOMXML.php", true);
xmlHttp.onreadystatechange = handleRequestStateChange;
xmlHttp.send(null);
}
// im Fehlerfall den Fehler anzeigen
fangen (e)
...{
alarm("Verbindung zum Server nicht möglich: " + e.toString());
}
}
}
// Verarbeitet die vom Server empfangene Antwort, serverseitige Statusrückruffunktion
Funktion handleRequestStateChange()
...{
if (xmlHttp.readyState == 4)
...{
// nur fortfahren, wenn der HTTP-Status „OK“ ist
if (xmlHttp.status == 200)
...{
versuchen
...{
// die Nachricht vom Server lesen
var xmlResponse = xmlHttp.responseXML;
//Potenzielle Fehler in IE und Opera erfassen
if(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Ungültige XML-Struktur: "+xmlHttp.responseText);
}
//Potenzielle Fehler in FireFox erfassen
var rootNodeName=xmlResponse.documentElement.nodeName;
if(rootNodeName=="parsererror")
...{
throw("Ungültige XML-Struktur: "+xmlHttp.responseText);
}
// Holen Sie sich die XML-Antwort vom Server, analysieren Sie sie und zeigen Sie sie auf der Webseite an
//Erhalte das XML-Dokumentelement
xmlRoot = xmlResponse.documentElement;
// Arrays mit Buchtiteln und ISBNs erhalten
cityArray=xmlRoot.getElementsByTagName("city");
//HTML-Ausgabe generieren
var html = "";
// Durch die Arrays iterieren und eine HTML-Struktur erstellen
for (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// Einen Verweis auf das <div>-Element auf der Seite erhalten
myDiv = document.getElementById("show");
// die HTML-Ausgabe anzeigen
myDiv.innerHTML = "Server sagt: <br />" + html;
}
fangen(e)
...{
//Fehlermeldung anzeigen
alarm("Fehler beim Lesen der Antwort: " + e.toString());
}
}
anders
...{
//Statusmeldung anzeigen
Alert("Beim Abrufen der Daten ist ein Problem aufgetreten: " +
xmlHttp.statusText);
}
}
}
///////4. JavaScript-Ereignisantwortfunktion (Onclick-Trigger)
Funktion CSparameter()
...{
// nur fortfahren, wenn xmlHttp nicht ungültig ist
if(xmlHttp)
...{
// versuche, eine Verbindung zum Server herzustellen
versuchen
...{
//Den Wert im Formular abrufen
var firstNumber=document.getElementById("firstNumber").value;
var secondNumber=document.getElementById("secondNumber").value;
//Als Parameter festlegen, um eine asynchrone Anfrage an CSparameter.php auf der Serverseite zu stellen
var param="firstNumber="+firstNumber+"&secondNumber="+secondNumber;
// das Lesen einer Datei vom Server initiieren
xmlHttp.open("GET", "CSparameter.php?"+param, true);
xmlHttp.onreadystatechange = handleRequestStateChangePara;
xmlHttp.send(null);
}
// im Fehlerfall den Fehler anzeigen
fangen (e)
...{
alarm("Verbindung zum Server nicht möglich: " + e.toString());
}
}
}
// Rückruffunktion zur Änderung des Serverstatus (der Server akzeptiert die Parameter vom Client und gibt nach logischer Berechnung eine XML-Antwort zurück. Der Client analysiert das XML und gibt die Aktualisierungen an die Seite zurück.)
// verarbeitet die vom Server empfangene Antwort
Funktion handleRequestStateChangePara()
...{
if (xmlHttp.readyState == 4)
...{
// nur fortfahren, wenn der HTTP-Status „OK“ ist
if (xmlHttp.status == 200)
...{
versuchen
...{
// die Nachricht vom Server lesen
var xmlResponse = xmlHttp.responseXML;
//Potenzielle Fehler in IE und Opera erfassen
if(!xmlResponse||!xmlResponse.documentElement)
...{
throw("Ungültige XML-Struktur: "+xmlHttp.responseText);
}
//Potenzielle Fehler in FireFox erfassen
var rootNodeName=xmlResponse.documentElement.nodeName;
if(rootNodeName=="parsererror")
...{
throw("Ungültige XML-Struktur: "+xmlHttp.responseText);
}
//Erhalte das XML-Dokumentelement
xmlRoot = xmlResponse.documentElement;
cityArray=xmlRoot.getElementsByTagName("result");
//HTML-Ausgabe generieren
var html = "";
// Durch die Arrays iterieren und eine HTML-Struktur erstellen
for (var i=0; i<cityArray.length; i++)
html += cityArray.item(i).firstChild.data + "<br/>";
// Einen Verweis auf das <div>-Element auf der Seite erhalten
myDiv = document.getElementById("result");
// die HTML-Ausgabe anzeigen
myDiv.innerHTML = "Server sagt: <br />" + html;
}
fangen(e)
...{
//Fehlermeldung anzeigen
alarm("Fehler beim Lesen der Antwort: " + e.toString());
}
}
anders
...{
//Statusmeldung anzeigen
Alert("Beim Abrufen der Daten ist ein Problem aufgetreten: " +
xmlHttp.statusText);
}
}
}
Serverseitiges PHP-Skript (verantwortlich für die Annahme asynchroner Anfragen vom Client, die Beantwortung dieser und die Rückgabe an den Client im XML-Format)
PHEchoXML.php (die erste Methode für PHP zur Generierung einer XML-Antwort, Echo gibt XML-Inhalte aus)
<?php
//Die erste Methode für serverseitiges PHP zum Generieren von XML-Dateien besteht darin, das XML direkt wiederzugeben.
header('Content-Type: text/xml');
//XML-Header generieren
echo '<?xml version="1.0" binding="UTF-8" standalone="yes"?>';
echo '<cities>';
$cityArray=array('Paris','London','NewYork','Peking','Tokoy');
foreach ($cityArray als $city)
{
echo '<city>'.$city.'</city>';
}
echo '</cities>'
?>
PHPDOMXML.php (Die zweite Methode für PHP zum Generieren einer XML-Antwort, wobei die DOM-API von PHP verwendet wird, um eine Antwort im XML-Format auszugeben)
<?php
header('Content-Type: text/xml');
$cityArray=array('Shanghai','Peking','Shanxi','Shandong');
//Erstelle ein XML-Dokument
$dom=new DOMDocument();
//Äußerstes Tag
$citiesTag=$dom->createElement('cities');
$dom->appendChild($citiesTag);
// Das darin enthaltene Tag kann durch Schleifen generiert werden
foreach ($cityArray als $city)
{
$cityTag=$dom->createElement('city');
$cityName=$dom->createTextNode($city);
$cityTag->appendChild($cityName);
$citiesTag->appendChild($cityTag);
}
//Speichern Sie die XML-Struktur als String und geben Sie sie aus
$xmlString=$dom->saveXML();
echo $xmlString;
?>
2. Parameterübertragung zwischen Client-Seite und Server-Seite:
Auf der clientseitigen Webseite kann ein Formular vorhanden sein, sodass Parameter an die <GET- oder POST-Methode, Variable oder XML> der Serverseite übergeben werden können und die Serverseite eine XML-Antwort generiert, die den Anforderungen entspricht die übergebenen Parameter (implementierte clientseitige und serverseitige Parameterinteraktion)
Siehe Beispiel:
Wie in 1 lautet das Skript auf der PHP-Seite für die Parameterübergabe wie folgt: CSparameter.php (akzeptiert die Parameter der asynchronen Anfrage des Clients, führt eine logische Verarbeitung durch und generiert eine XML-Antwort, die an den Client zurückgesendet wird) <?php
//Passen Sie die Fehlerbehandlungsfunktion auf der Serverseite an
require_once('error_handler.php');
header('Content-Type: text/xml');
//Parameter der asynchronen Client-Anfrage akzeptieren
$firstNumber=$_GET['firstNumber'];
$secondNumber=$_GET['secondNumber'];
//Logische Berechnungen durchführen
$result=$firstNumber/$secondNumber;
//Eine Antwort im XML-Format generieren und an den Client zurücksenden
$dom=new DOMDocument();
$resultsTag=$dom->createElement('results');
$dom->appendChild($resultsTag);
$resultTag=$dom->createElement('result');
$resultText=$dom->createTextNode($result);
$resultTag->appendChild($resultText);
$resultsTag->appendChild($resultTag);
$xmlString=$dom->saveXML();
echo $xmlString;
?>
3. Behandlung von Fehlerausnahmen auf PHP-Seite (die hier genannten Fehler bzw. Ausnahmen beziehen sich auf logische Fehler):
a) Standardmäßig löst PHP keine Ausnahme aus, wenn ein Fehler oder eine Ausnahme auftritt (dies liegt daran, dass display_errors in der php.ini standardmäßig auf „off“ gesetzt ist und der Fehler im Apache-Fehlerprotokolldatensatz gespeichert wird). geschrieben Schwer zu debuggen. <Es ist oft schwierig, vom Browser angezeigte Fehler zu finden>
b) Wenn display_errors jedoch aktiviert ist, wird der Fehler angezeigt, die Fehlermeldung ist jedoch unfreundlich.
http://www.downcodes.com/
c) Sie können Ihre eigene PHP-Funktion zur Behandlung von Fehlerausnahmen schreiben (display_errors muss nicht unbedingt aktiviert sein), um Fehler auf offensichtliche Weise anzuzeigen, um das Debuggen zu erleichtern.
Normalerweise schreiben Sie Ihre eigene Ausnahmebehandlungsfunktion wie folgt:
Zeigt die definierte serverseitige Fehlerausnahmefunktion error_handler.php an (kann problemlos in PHP-Programmen wiederverwendet werden)
<?php
//Legen Sie eine benutzerdefinierte Fehlerbehandlungsfunktion und eine benutzerdefinierte Fehlerausnahmebehandlungsmethode fest
set_error_handler('error_handler', E_ALL);
Funktion error_handler($errNo,$errStr,$errFile,$errLine)
{
//Wenn der Ausgabepuffer nicht leer ist, leeren Sie ihn
if(ob_get_length()) ob_clean();
//Benutzerdefinierte Ausgabe definieren
$error_message='ERRNO: '.$errNo.chr(10).'TEXT: '.$errStr.chr(10).'LOCATION: '.$errFile.', Line'.$errLine;
echo $error_message;
Ausfahrt;
}
?>
4. Serverseitiger Zugriff auf die Datenbank <Verwenden Sie MySQL, um auf Daten zuzugreifen und echte Dynamik zu erzielen>
Dies ist bereits sehr klassisch, Sie können MySQL, MSSQL, Oracle usw. verwenden.
a) Öffnen Sie die Datenbank; b) SQL-Anweisungsabfrage c) Schließen Sie die Datenbank
5. Kapselung und Architektur des serverseitigen PHP-Programms (serverseitiges PHP-Programm führt den Entwurfsmodus ein)
a) appname.php <Client-Anfrage akzeptieren>
b) appname.class.php <Serverseitige Logik, Datenbankoperationen, Fehlerbehandlung usw. in Klassen kapseln, einschließlich Attributen, Methoden, Konstruktoren und Destruktoren>
c) config.php
d) error_handler.php
ist ein Beispiel für die Einführung von Entwurfsmustern auf der Serverseite: (Entwerfen Sie die Programmarchitektur serverseitiger PHP-Skripte, um die Skalierbarkeit und Wiederverwendbarkeit zu verbessern.)
Ein sehr einfaches Keywords Suggest-Programm: (einschließlich index.html, css/style.css, js.js und PHP-Code php/suggest.php, suggest.class.php, error_handler.php, config.php unterstützt Datenbank)
index.html(css/style.css, js.js; beachten Sie, dass zwei JS-Client-Ereignisse onkeyup, onclick auslösen)
onkeyup sendet asynchron in Echtzeit eine Anfrage an den Server, wenn der Benutzer Eingaben macht, und onclick sendet eine Anfrage an den Server, wenn der Benutzer auf „Suchen“ klickt.
<!doctype html public "-//w3c//dtd html 4.0 tRANSITIONAL//en">
<html>
<Kopf>
<title> Designmuster PHP AJAX (Schlüsselwörter schlagen DEMO vor) </title>
<link type="text/css" rel="stylesheet" href="css/style.css"/>
<script type="text/javascript" src="js.js"></script>
</head>
<Körper>
<noscript>
<strong>Für dieses Beispiel ist ein JavaScript-fähiger Browser erforderlich!</strong>
</noscript>
<div class="project">
<span class="title">Willkommen beim Design Pattern PHP AJAX (Schlüsselwörter empfehlen DEMO) </span>
<br />
<br />
<div class="news">
<br /><input type="text" id="keyword" onkeyup="keyup()" /><input type="button" id="search" onclick="search()" value="search"> <br /><br />
Schlüsselwörter vorschlagen:
<div id="show"></div>
</div>
</div>
</body>
</html>
css/style.css
Körper
{...}{
Schriftfamilie: Arial;
Schriftgröße: klein;
Hintergrundfarbe: #fff;
}
.Titel
{...}{
Schriftgröße:x-groß;
}
div.Projekt
{...}{
Hintergrundfarbe: #99ccff;
Polsterung:5px;
Grenze:#000099 1 Pixel durchgehend;
}
div.news
{...}{
Hintergrundfarbe:#fffbb8;
Polsterung:2px;
Rand: 1px gestrichelt;
}
#zeigen
{...}{
Farbe: #008000;
Schriftstil: kursiv;
}js.js (Antwortfunktion in JS und Rückruffunktion definieren, damit der Client die Serverantwort verarbeitet)
////////////////////////////////////////////////////////////////////////// /// /////////
//1. XMLHttpRequest-Objekt erstellen
////////////////////////////////////////////////////////////////////////// /// /////////
var xmlHttp = createXmlHttpRequestObject();
Funktion createXmlHttpRequestObject()
...{
var xmlHttp;
versuchen
...{
// versuchen, ein XMLHttpRequest-Objekt zu erstellen
xmlHttp = new XMLHttpRequest();
}
fangen(e)
...{
// gehe von IE6 oder älter aus
var XmlHttpVersions = new Array('MSXML2.XMLHTTP.6.0',
'MSXML2.XMLHTTP.5.0',
'MSXML2.XMLHTTP.4.0',
'MSXML2.XMLHTTP.3.0',
'MSXML2.XMLHTTP',
'Microsoft.XMLHTTP');
for (var i=0; i<XmlHttpVersions.length && !xmlHttp; i++)
...{
versuchen
...{
// versuchen, ein XMLHttpRequest-Objekt zu erstellen
xmlHttp = new ActiveXObject(XmlHttpVersions[i]);
}
fangen (e) ...{}
}
}
if (!xmlHttp)
Alert("Fehler beim Erstellen des XMLHttpRequest-Objekts.");
anders
return xmlHttp;
}
// Zeigt die korrekte Antwort vom Server an das Div mit der ID „show“ an
Funktionsanzeige (Meldung)
...{
showDIV=document.getElementById("show");
showDIV.innerHTML=Nachricht;
}
//Zeige die Fehlermeldung der serverseitigen Antwort auf das Div mit der ID von show an
Funktion displayError(Fehlermeldung)
...{
//Fehlermeldung anzeigen
display("Fehler beim Abrufen der neuen Nachricht!<br/>"+errormessage);
}
////////////////////////////////////////////// /// //////////
//2. Ereignisgesteuerte Funktion (Keyup-Funktion)
////////////////////////////////////////////////////////////////////////// /// /////////
var keyupAddress="php/suggest.php?action=keyup&keyword=";
Funktion keyup()
...{
if(xmlHttp)
...{
//Eine asynchrone Anfrage senden, wenn der Server nicht ausgelastet ist
if(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
versuchen
...{
var keyword=document.getElementById("keyword").value;
//Eine asynchrone Anfrage stellen
xmlHttp.open("GET",keyupAddress+keyword,true);
xmlHttp.onreadystatechange=handlerreadystatechange;
xmlHttp.send(null);
}
fangen(e)
...{
displayError(e.toString);
}
}
}
}
////////////////////////////////////////////////////////////////////////// /// /////////
//3. Rückruffunktion, diese Funktion wird ausgelöst, wenn sich der Serverantwortstatus ändert.
////////////////////////////////////////////////////////////////////////// /// /////////
Funktion handlereadystatechange()
...{
if(xmlHttp.readyState==4)
...{
if(xmlHttp.status==200)
...{
versuchen
...{
//Serverantwort abrufen
var xmlResponse = xmlHttp.responseXML;
suggestArray=xmlResponse.getElementsByTagName("suggest");
var showText="";
for(var i=0;i<suggestArray.length;i++)
...{
var textNodes=suggestArray[i].getElementsByTagName("text");
var timesNodes=suggestArray[i].getElementsByTagName("times");
for(var j=0;j<textNodes.length;j++)
...{
showText+=textNodes[j].childNodes[0].nodeValue+" ("+timesNodes[j].childNodes[0].nodeValue+") <br />";
}
}
//Zeigt die Antwort auf die Seite an
display(showText);
}
fangen(e)
...{
displayError(e.toString());
}
}
}
}
////////////////////////////////////////////////////////////////////////// /// /////////
//2. Ereignisgesteuerte Funktion (Suchfunktion)
////////////////////////////////////////////////////////////////////////// /// /////////
var searchAddress="php/suggest.php?action=search&keyword=";
Funktion search()
...{
if(xmlHttp)
...{
//Eine asynchrone Anfrage senden, wenn der Server nicht ausgelastet ist
if(xmlHttp.readyState==0||xmlHttp.readyState==4)
...{
versuchen
...{
var keyword=document.getElementById("keyword").value;
//Eine asynchrone Anfrage stellen
xmlHttp.open("GET",searchAddress+keyword,true);
xmlHttp.onreadystatechange=handlerreadystatechange;
xmlHttp.send(null);
}
fangen(e)
...{
displayError(e.toString);
}
}
}
}
Abschließende Anmerkung: Die Programmstruktur des serverseitigen PHP-Skripts (suggest.php ist die Hauptverarbeitungsfunktion auf der Serverseite, außerdem gibt es suggest.class.php, error_handler.php, config.php usw.)
suggest.php (rufen Sie die Parameter des Clients ab und rufen Sie die beiden Methoden der Suggest-Klasse auf, um eine Antwort im XML-Format zu generieren und an den Client zurückzusenden)
<?php
require_once('suggest.class.php');
header('Content-Type: text/xml');
//Stellen Sie sicher, dass der Browser des Benutzers die Ergebnisse nicht zwischenspeichert
header('Läuft ab: Mi, 23. Dezember 1980 00:30:00 GMT');
header('Last-Modified: '.gmdate('D, d MYH:i:s').' GMT' );
header('Cache-Control: kein Cache, muss erneut validiert werden');
header('Pragma: no-cache');
$action=$_GET['action'];
$keyword=$_GET['keyword'];
$oSuggest=new suggest();
if($action=='keyup'&&$keyword!='')
{
$suggestXML=$oSuggest->getSuggests($keyword);
}
if($action=='search'&&$keyword!='')
{
$suggestXML=$oSuggest->submitKeyword($keyword);
}
echo $suggestXML;
?>suggest.class.php-Klasse
<?php
require_once('error_handler.php');
require_once('config.php');
Klasse vorschlagen
{
//Mitgliedsvariablen
private $conn;
//Konstruktor, Datenbanklink
function__construct()
{
$this->conn=new mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_DATABASE);
if (mysqli_connect_errno()) {
printf("Verbindung fehlgeschlagen: %s", mysqli_connect_error());
Ausfahrt();
}
}
//Destruktor, trennen Sie die Datenbankverbindung
Funktion __destruct()
{
$this->conn->close();
}
//getSuggests-Mitgliedsfunktion (diese Funktion reagiert hauptsächlich auf die clientseitige Aktion = keyup, d. h. eine asynchrone Anfrage, wenn der Benutzer tippt)
öffentliche Funktion getSuggests($keyword)
{
//Vorschlag generieren (Schlüsselwörter in der Datenbank generieren, die mit der ersten Hälfte des eingegebenen Schlüsselworts übereinstimmen)
$suggest_query='Wählen Sie * aus Schlüsselwörtern aus, bei denen das Schlüsselwort „.$keyword.'%“ lautet. Reihenfolge nach Zeiten, Abstiegslimit 5';
$suggest_result=$this->conn->query($suggest_query);
$suggest_num=$suggest_result->num_rows;
$strOUT='<?xml version="1.0" binding="UTF-8" standalone="yes"?>';
if($suggest_num==0)
{
//$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>0</times></suggest></suggests>';
}
anders
{
$strOUT=$strOUT."<suggests>";
for($i=0;$i<$suggest_num;$i++)
{
$suggest_row = $suggest_result->fetch_row();
$strOUT=$strOUT.'<suggest><text>'.$suggest_row[1].'</text><times>'.$suggest_row[2].'</times></suggest>';
}
$strOUT=$strOUT.'</suggests>';
}
return $strOUT;
}
//submitKeyword-Mitgliedsfunktion (diese Funktion reagiert hauptsächlich auf die clientseitige Aktion = Suche, d. h. die asynchrone Anfrage, wenn der Benutzer auf „Suchen“ klickt)
öffentliche FunktionsubmitKeyword($keyword)
{
$select_query='wählen Sie * aus Schlüsselwörtern aus, wobei keyword=''.$keyword.''';
$select_result=$this->conn->query($select_query);
$select_num=$select_result->num_rows;
// Fügen Sie der Datenbank neue Schlüsselwörter hinzu, wenn Sie auf sie stoßen, und erhöhen Sie die Anzahl vorhandener Schlüsselwörter, wenn Sie auf sie stoßen.
$strOUT='<?xml version="1.0" binding="UTF-8" standalone="yes"?>';
//Bereits vorhanden, Anzahl erhöhen
if($select_num!=0)
{
$select_row = $select_result->fetch_row();
$times_now=$select_row[2];
$times_now=$times_now+1;
$update_query='update keywords set times ='.$times_now.' where keyword=''.$keyword.''';
$update_result=$this->conn->query($update_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>'.$times_now.'</times></suggest></suggests>';
}
anders
{
//Kein Speichern des Einfügens
$insert_query='In Schlüsselwörter (Schlüsselwort, Zeiten) Werte einfügen (''.$keyword.'',1)';
$insert_result=$this->conn->query($insert_query);
$strOUT=$strOUT.'<suggests><suggest><text>'.$keyword.'</text><times>1</times></suggest></suggests>';
}
return $strOUT;
}
}
?>
Die letzten beiden Funktionen, config.php, speichern Anwendungskonfigurationsinformationen (z. B. Datenbankkonfigurationsinformationen).
<?php
define('DB_HOST', 'localhost');
define('DB_USER','phpajaxuser');
define('DB_PASSWORD','phpajaxuser');
define('DB_DATABASE','phpajax');
?>
error_handler.php speichert die benutzerdefinierte Ausnahmebehandlung
<?php
//Benutzerdefinierte Fehlerbehandlungsfunktion festlegen
set_error_handler('error_handler', E_ALL);
function error_handler($errNo,$errStr,$errFile,$errLine)
{
if(ob_get_length()) ob_clean();
$error_message='ERRNO: '.$errNo.chr(10).'TEXT: '.$errStr.chr(10).'LOCATION: '.$errFile.' '.$errLine;
echo $error_message;
Ausfahrt;
}
?>Schließlich sind SQL-Anweisungen erforderlich, um die Datenbank hinzuzufügen und Schlüsselwörter in der Datenbank zu speichern.
TABELLE „Schlüsselwörter“ ERSTELLEN (
`id` int(10) unsigned NOT NULL auto_increment,
`keyword` varchar(32) NOT NULL default '',
`times` int(10) unsigned NOT NULL default '0',
PRIMÄRSCHLÜSSEL („id“)
) TYPE=MyISAM AUTO_INCREMENT=1;
6. Wenig Wissen über PHP für zukünftige Forschung:
Wie PHP Daten von einem Remote-Server liest (ähnlich wie Web Crawl):
file_get_contents;
Oder CURL<Client-URL-Bibliothek>www.php.net/curl