10. Servers in PHP
Aangezien PHP-programma’s door een WEB-server kunnen worden uitgevoerd, wordt een dergelijk programma een serverprogramma dat meerdere clients kan bedienen. Vanuit het perspectief van de client komt het aanroepen van een WEB-service neer op het opvragen van de URL van die service. De client kan in elke willekeurige programmeertaal worden geschreven, met name in PHP. In dat laatste geval maken we dan gebruik van de netwerkfuncties die we zojuist hebben besproken. We moeten bovendien weten hoe we met een WEB-service moeten „communiceren”, dat wil zeggen het http-communicatieprotocol tussen een webserver en zijn clients begrijpen. Dat is het doel van de volgende programma’s.
Dankzij de in paragraaf 9.2 beschreven webclient hebben we een deel van het protocol HTTP kunnen ontdekken.
In hun eenvoudigste vorm verloopt de communicatie tussen client en server als volgt:
- de client opent een verbinding met poort 80 van de webserver
- hij doet een verzoek om een document
- de webserver verstuurt het gevraagde document en verbreekt de verbinding
- de client sluit op zijn beurt de verbinding
De client kan van verschillende aard zijn: een tekst in het formaat HTML, een afbeelding, een video, ... Het kan een bestaand document zijn (statisch document) of een document dat direct door een script wordt gegenereerd (dynamisch document). In het laatste geval spreken we van webprogrammering. Het script voor het dynamisch genereren van documenten kan in verschillende talen worden geschreven: PHP, Python, Perl, Java, Ruby, C#, VB.net, ...
We gebruiken hier PHP om tekstdocumenten dynamisch te genereren.
 |
- in [1] opent de client een verbinding met de server, vraagt een script PHP aan en stuurt al dan niet parameters naar dit script
- In [2] laat de webserver het script PHP uitvoeren door de interpreter PHP. Dit script genereert een document dat naar de client [3] wordt verzonden
- sluit de server de verbinding af. De client doet hetzelfde.
De webserver kan meerdere clients tegelijkertijd verwerken. Met het softwarepakket WampServer is de webserver een Apache-server, een open-source-server van de Apache Foundation (http://www.apache.org/). In de volgende toepassingen moet WampServer worden gestart. Dit activeert drie programma's: de Apache-webserver, SGBD MySQL en de interpreter PHP.
De scripts die door de webserver worden uitgevoerd, worden geschreven met de tool NetBeans. Tot nu toe hebben we PHP-scripts geschreven die in een consoleconttext worden uitgevoerd:
 |
De gebruiker gebruikt de console om de uitvoering van een script PHP aan te vragen en de resultaten daarvan te ontvangen.
In de client/server-toepassingen die hierna volgen,
- wordt het clientscript uitgevoerd in een console-omgeving
- wordt het serverscript uitgevoerd in een webcontext
 |
Het serverscript PHP mag zich niet zomaar ergens in het bestandssysteem bevinden. De webserver zoekt namelijk op locaties die via de configuratie zijn opgegeven naar de statische en dynamische documenten waar om wordt gevraagd. De standaardconfiguratie van WampServer zorgt ervoor dat de documenten worden gezocht in de map <WampServer>/www, waarbij <WampServer> de installatiemap van WampServer is. Als een webclient dus een document D opvraagt met de URL [http://localhost/D], zal de webserver het document D met het pad [<WampServer>/www/D] leveren.
In de volgende voorbeelden plaatsen we de serverscripts in de map [www/exemples-web]. Als een serverscript S.php heet, wordt het bij de webserver opgevraagd via de URL en [http://localhost/exemples-web/S.php]. Het document [<WampServer>/www/exemples-web/S.php] wordt dan aan de gebruiker geleverd.
 |
Om met NetBeans een serverscript te maken voor , gaan we als volgt te werk:
 |
- in [1] maken we een nieuw project aan
- in [2] kiezen we de categorie [PHP] en het project [PHP Application]
 |
- in [3] geven we het project een naam
- in [4] kiezen we een map voor het project
- in [5] geven we aan dat het script door een lokale webserver moet worden uitgevoerd (de URL van het script zal de vorm http://localhost/... hebben). De lokale webserver is de Apache-webserver van WampServer.
- In [6] geven we de URL van het project op. Hier bepalen we dat een script S.php van het project zal worden opgevraagd met de URL [http://localhost/exemples-web/S.php]. Op basis van het bovenstaande betekent dit dat het pad naar het script S.php in het bestandssysteem [<WampServer>/www/exemples-web/S.php] zal zijn. Dit wordt aangegeven in [7]. We vragen hier dat elk script S.php van het project wordt gekopieerd naar de directorystructuur van de Apache-webserver.
- in [8], het nieuwe project.
Laten we een testscript schrijven:
 |
- in [1] maken we in het project [exemples-web] een eerste script PHP
- in [2] geven we het een naam
- in [3], en nadat we het hebben aangemaakt, vullen we het in met de volgende inhoud
Vervolgens moet WampServer worden gestart.
 |
- in [4] voeren we het webscript [exemple1.php] uit. NetBeans start dan de standaardbrowser van de computer en vraagt deze om URL, [http://localhost/exemples-web/exemple1.php] en [5]
- in [6] weer te geven; de browser toont wat het serverscript naar de client heeft geschreven.
Vervolgens zullen we twee soorten webclients tegenkomen:
- een browser zoals hierboven beschreven. We hebben geschreven dat de webserver een antwoord verstuurde in de vorm: headers HTTP, lege regel, tekst. De browser geeft alleen texte weer.
- een script PHP dat het volledige antwoord weergeeft: headers HTTP, lege regel, tekst.
Vervolgens
- zullen de serverscripts worden geschreven zoals [exemple1.php] hierboven
- en de clientscripts zoals de consolescripts die we tot nu toe hebben geschreven.
10.1. Client-/servertoepassing voor datum en tijd
10.1.1. De server (web_01)
<?php
// tijd: aantal milliseconden sinds 01/01/1970
// weergaveformaat voor datum en tijd
// d: dag in twee cijfers
// m: maand (2 cijfers)
// y: jaar (2 cijfers)
// H: uur 0,23
// i: minuten
// s: seconden
print date("d/m/y H:i:s",time());
In principe schrijft het bovenstaande script PHP de huidige tijd op het scherm. Wanneer het echter door een webserver wordt uitgevoerd, wordt stream nr. 1, die gewoonlijk aan het scherm is gekoppeld, omgeleid naar de verbinding tussen de server en de client. In een webcontext stuurt het bovenstaande script de huidige tijd dus als tekst naar de client.
Laten we dit script uitvoeren in NetBeans:
 |
- in [1] voeren we het script uit. Er wordt dan een webbrowser gestart.
- in [2] wordt de door de webbrowser aangevraagde URL
- in [3], de tekst die door het serverscript is verzonden
De clientbrowser gebruikt het protocol HTTP om met de webserver te communiceren. We hebben de opbouw van dit protocol al beschreven.
De client verstuurt tekstregels die in drie delen kunnen worden opgesplitst: HTTP-headers, een lege regel en het document. Het naar de webserver verzonden document is meestal leeg of bestaat uit een reeks parami=vali-parameters, waarbij vali een waarde is die door de gebruiker in een HTML-formulier is ingevoerd.
Het antwoord van de server heeft dezelfde structuur: headers HTTP, lege regel, document, waarbij document ditmaal het document is dat door de clientbrowser is opgevraagd. Als de client parameters heeft doorgegeven, hangt het geleverde document doorgaans af van deze parameters.
Met de Firefox-browser is het mogelijk om de daadwerkelijke communicatie tussen de client en de webserver te bekijken. Er bestaat een plug-in voor Firefox, genaamd Firebug, waarmee deze communicatie kan worden getraceerd. Firebug is beschikbaar op de URL [https://addons.mozilla.org/fr/firefox/addon/firebug/]. Als je de browser Firefox gebruikt om deze URL te bezoeken, kun je de plug-in Firebug downloaden. We gaan er verderop vanuit dat de Firebug-plug-in is gedownload en geïnstalleerd. Deze is beschikbaar via een optie in het Firefox-menu:
 |
Er wordt een Firebug-venster geopend in het Firefox-browservenster. Dit venster bevat zelf ook een menu:
 |
Om de communicatie tussen client en server tijdens een verzoek HTTP te bekijken, voeren we het verzoek URL [http://localhost/exemples-web/web_01.php] uit met de Firefox-browser. Het Firebug-venster vult zich vervolgens met informatie:
 |
Hierboven zien we een overzicht van de communicatie tussen client en server:
- [1]: de client heeft het commando HTTP verzonden: GET /exemples-web/web_01.php HTTP/1.1 om het document [web01.php] op te vragen
- [2]: de server heeft het antwoord verzonden: HTTP/1.1 200 OK, waarmee wordt aangegeven dat het gevraagde document is gevonden.
Met Firebug kun je de volledige communicatie bekijken. Je hoeft alleen maar de URL te „uitvouwen”:
 |
Hierboven zien we de HTTP-headers die zijn uitgewisseld tussen de client (verzoek) en de server (antwoord). Het is mogelijk om de broncode van de uitwisselingen te verkrijgen, c.a.d, en de daadwerkelijk uitgewisselde tekstregels, [1]. We krijgen dan de volgende broncode:
 |
Om een clientscript voor de webserver te schrijven, hoeven we alleen maar het gedrag van de browser na te bootsen. Nadat er een verbinding met de server is geopend, zou het clientscript de 8 regels van het bovenstaande verzoek kunnen verzenden. In feite is niet alles noodzakelijk en zullen we alleen de volgende drie regels verzenden:
- regel 1: specificeert het opgevraagde document en het gebruikte protocol HTTP
- regel 2: geeft de hostnaam van de client-scriptmachine aan
- regel 3: geeft aan dat de client na de uitwisseling de verbinding met de server zal verbreken
Laten we nu eens kijken naar het antwoord van de server. We weten dat dit is gegenereerd door het script PHP [web_01.php]. Hierboven zien we de headers HTTP van het antwoord. Uit de code van het script [web01.php] blijkt dat dit script ze niet heeft gegenereerd. Laten we de configuratie van het serverscript nog eens bekijken:
 |
Het is de webserver die de HTTP-headers van het antwoord heeft gegenereerd. Het serverscript kan deze zelf genereren. We zullen hier iets verderop een voorbeeld van zien.
We hebben gezegd dat het antwoord van de webserver de volgende vorm had: headers HTTP, lege regel, document. Als het document een tekstdocument is, kunnen we dit zien in het tabblad [Réponse] van Firebug:
 |
Dit antwoord is gegenereerd door het script [web_01.php].
10.1.2. Een client (client1_web_01)
We schrijven nu een clientscript voor de vorige service. We weten dat de client het volgende moet doen:
- een verbinding met de webserver tot stand brengen
- de tekst verzenden: headers HTTP, lege regel
- het volledige antwoord van de server lezen totdat deze de verbinding met de client verbreekt
- de verbinding met de server verbreken
Het clientscript wordt uitgevoerd in een NetBeans-consoleomgeving:
 |
- in [1] is het clientscript [client1_web_01.php] opgenomen in het NetBeans-project [exemples]
- in [2] zijn de eigenschappen van het NetBeans-project [exemples]
- in [3] wordt het NetBeans-project [exemples] uitgevoerd in de "opdrachtregel"-modus, die we ook wel de "console"-modus noemen.
De code van het clientscript is als volgt:
<?php
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// verbinding tot stand gebracht op poort 80 van $HOTE
$connexion = fsockopen($HOTE, $PORT);
// fout?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion,"Connection: close\n");
// lege regel
fputs($connexion,"\n");
// de server zal nu reageren op het kanaal $connexion. Hij zal al
// zijn gegevens versturen en vervolgens het kanaal sluiten. De client leest dus alles wat binnenkomt van $connexion
// totdat het kanaal wordt gesloten
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
}//terwijl
// de client op zijn beurt de verbinding verbreekt
fclose($connexion);
// einde
exit;
Opmerkingen
- regel 8: een verbinding met de server openen
- regel 16: commando HTTP GET
- regel 18: commando HTTP Host
- regel 20: commando HTTP Verbinding
- regel 22: lege regel
- regels 26-28: alle tekstregels lezen die door de server worden verzonden totdat deze de verbinding verbreekt.
- regel 30: de client verbreekt op zijn beurt de verbinding
Resultaten
Het uitvoeren van het clientscript levert de volgende resultaten op:
Opmerkingen
- regels 1-7: het antwoord HTTP van de webserver.
- regel 8: de lege regel die het einde van de headers aangeeft HTTP
- regels 9 en verder: het document. In dit geval is het een eenvoudige tekst met de huidige datum en tijd. Dit is de tekst die door het script PHP naar uitvoer nr. 1 wordt geschreven.
- regel 1: de server antwoordt dat hij het gevraagde document heeft gevonden.
- regel 2: huidige datum en tijd van de server
- regel 3: identiteit van de webserver
- regel 4: geeft aan dat het document dat volgt, is gegenereerd door een script PHP
- regel 5: aantal tekens van het document
- regel 6: de server geeft aan dat hij, na het verzenden van het document, de verbinding zal verbreken
- regel 7: geeft aan dat het door de server verzonden document tekst is in het formaat HTML. Dit klopt hier niet. Het document is tekst zonder specifieke opmaak. Wanneer het document geen tekst in het HTML-formaat is, moet het script PHP dit aangeven. Dat hebben we hier niet gedaan.
10.1.3. Een tweede client (client2_web_01)
De vorige client gaf alles weer wat de webserver hem stuurde. In de praktijk negeren we meestal de HTTP-headers van het antwoord en gebruiken we alleen het documentgedeelte. We proberen hier de datum en tijd op te halen die door het PHP-script van de server zijn verzonden. We gaan deze informatie ophalen met behulp van een reguliere expressie.
<?php
// de door een webserver verzonden informatie ophalen
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_01.php";
// een verbinding openen op poort 80 van $HOTE
$connexion = fsockopen($HOTE, $PORT);
// fout?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion,"Connection: close\n");
// lege regel
fputs($connexion,"\n");
// de server zal nu reageren op het kanaal $connexion. Hij zal al
// deze gegevens en sluit vervolgens het kanaal. De client leest dus alles wat binnenkomt van $connexion
// totdat hij de regel vindt die hij zoekt, in de vorm dd/mm/jj hh:mm:ss
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
if (preg_match("/(\d\d)\/(\d\d)\/(\d\d) (\d\d):(\d\d):(\d\d)/", $ligne, $champs)) {
// en haalt de # velden op
array_shift($champs); // verwijdert het eerste element uit de velden-array
// we halen de 6 velden op in 6 variabelen
list($j, $m, $a, $h, $i, $s) = $champs;
// weergave van het resultaat
print "\ndateheure=[$j,$m,$a,$h,$i,$s]\n";
}//if
}//while
// de klant verbreekt op zijn beurt de verbinding
fclose($connexion);
// einde
exit;
Resultaten
10.2. Het ophalen door de server van de door de client verzonden parameters
In het protocol HTTP heeft een client twee manieren om parameters door te geven aan de webserver:
- hij vraagt de URL van de dienst aan in de vorm van
GET url?param1=val1¶m2=val2¶m3=val3… HTTP/1.0
waarbij de waarden vali eerst moeten worden gecodeerd, zodat bepaalde gereserveerde tekens worden vervangen door hun hexadecimale waarde.
- hij vraagt de URL van de dienst aan in de vorm
POST url HTTP/1.0
en voegt vervolgens in de HTTP-headers die naar de server worden verzonden de volgende header toe:
De rest van de door de client verzonden headers eindigt met een lege regel. Vervolgens kan hij zijn gegevens verzenden in de vorm
waarbij de waarden vali, net als bij de methode GET, vooraf moeten worden gecodeerd. Het aantal tekens dat naar de server wordt verzonden, moet N zijn, waarbij N de waarde is die is opgegeven in de header
Het script PHP, dat de eerder door de client verzonden parameters parami ophaalt, haalt hun waarden uit de tabel:
- $_GET["parami"] voor een opdracht GET
- $_POST["parami"] voor een opdracht POST
10.2.1. De klant GET (client1_web_02)
Het onderstaande script PHP verzendt drie parameters [nom, prenom, age] naar de server.
<?php
// client: stuurt voornaam, achternaam en leeftijd naar de server via de methode GET
// gegevens
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_02.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// verbinding met de webserver
$connexion = fsockopen($HOTE, $PORT);
// terugkeren bij fout
if (!$connexion) {
print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
exit;
}//if
// informatie naar de server verzenden PHP
// de gegevens worden gecodeerd
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
// console-log
print "infos envoyées au serveur (GET)=$infos\n";
print "URL demandée=[$URL?$infos]\n\n";
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $URL?$infos HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion,"Connection: close\n");
// lege regel
fputs($connexion,"\n");
// de server zal nu reageren op het kanaal $connexion. Hij zal alle
// zijn gegevens en sluit vervolgens het kanaal. De client leest alles wat binnenkomt van $connexion totdat het kanaal wordt gesloten
while ($ligne = fgets($connexion, 1000))
print "$ligne";
// de client sluit op zijn beurt de verbinding
fclose($connexion);
Opmerkingen
- regel 7: URL van het serverscript
- regel 8: de waarden van de 3 parameters
- regel 10: een verbinding met de webserver tot stand brengen
- regel 18: codering van de 3 parameters. We werken met een script dat is geschreven in NetBeans met een tekencodering in UTF-8. De 3 parameterwaarden van regel 8 worden dus gecodeerd in UTF-8. De functie utf8_decode zet hun codering om naar ISO-8859-1. Daarna kunnen ze worden gecodeerd voor URL. Alle niet-alfabetische tekens worden vervangen door %xx, waarbij xx de hexadecimale waarde van het teken is. Spaties worden vervangen door het teken +.
- regel 24: de gevraagde URL is $URL?$infos, waarbij $infos de vorm nom=val1&prenom=val2&age=val3 heeft.
10.2.2. De server (web_02)
De server geeft gewoon weer wat hij ontvangt.
<?php
// foutafhandeling
ini_set("display_errors", "off");
// de server haalt de door de client verzonden informatie op
// hier voornaam=P&achternaam=N&leeftijd=A
// deze gegevens zijn automatisch beschikbaar in de variabelen
// $_GET['prenom'], $_GET['nom'], $_GET['age']
// en worden teruggestuurd naar de client
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// parameters verzonden naar de server
$prenom = isset($_GET['prenom']) ? $_GET['prenom'] : "";
$nom = isset($_GET['nom']) ? $_GET['nom'] : "";
$age = isset($_GET['age']) ? $_GET['age'] : "";
// antwoord aan de klant
$réponse = "informations reçues du client [" .
utf8_encode(htmlspecialchars($prenom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($nom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($age, ENT_QUOTES)) . "]\n";
print $réponse;
Opmerkingen
- regel 13: stelt de header HTTP "Content-Type" in. Standaard verstuurt de webserver de header
waarmee wordt aangegeven dat het antwoord tekst is in het formaat HTML. Hier zal het antwoord onopgemaakte tekst zijn met tekens die zijn gecodeerd in UTF-8:
De headers HTTP moeten vóór het antwoord van de server worden verzonden. Daarom staat hierboven de aanroep van de functie header vóór elke instructie print.
- regels 16-18: de 3 parameters worden opgehaald uit de tabel $_GET.
- regel 21: hier wordt de tekenreeks samengesteld die als antwoord naar de client wordt verzonden. Bepaalde tekens hebben een speciale betekenis in HTML en moeten worden vervangen door HTML-entiteiten om te kunnen worden weergegeven. htmlspecialchars($string) vervangt al deze tekens door hun equivalent in de tekenreeks $string. Het teken $ wordt bijvoorbeeld &. Aangezien we in regel 13 hebben aangegeven dat het antwoord uit de tekst UTF-8 zou bestaan, coderen we de opgehaalde waarden vervolgens in UTF-8.
- regel 25: het antwoord wordt naar de client verzonden
Test 1
Laten we het script [web_02] uitvoeren vanuit NetBeans. Er wordt dan een browser gestart om de URL [http://localhost/exemples-web/web_02.php] weer te geven:
 |
- in [1] geeft de browser de URL [http://localhost/exemples-web/web_02.php] weer. Omdat we geen parameters aan deze URL hebben toegevoegd, heeft de server met lege parameters gereageerd. Ter herinnering: het antwoord van de server is het antwoord dat is geschreven met de instructie print.
- In [2] voegen we parameters toe aan URL. Deze keer stuurt het serverscript ze wel terug.
Merk op dat NetBeans niet nodig is om een serverscript uit te voeren. Het volstaat om de URL van het serverscript in een browser in te voeren om dit script uit te voeren.
Test 2
We voeren in NetBeans de client [client1_web_02.php] uit. We krijgen het volgende antwoord:
- regel 1: codering van de 3 parameters. We zien dat het teken û is veranderd in %FB.
- regel 12: het antwoord van de server
10.2.3. De client POST (client2_web_03)
Een HTTP-client stuurt de volgende tekstreeks naar de webserver: headers HTTP, lege regel, document. In de vorige client was deze reeks als volgt:
Er was geen document. Er bestaat nog een andere manier om parameters door te geven, de zogenaamde POST-methode. In dit geval is de tekstreeks die naar de webserver wordt verzonden als volgt:
Deze keer maken de parameters die bij de client GET in de headers HTTP waren opgenomen, bij de client POST deel uit van het document dat achter de headers wordt verzonden.
Het script van de client POST is als volgt:
<?php
// klant: stuurt voornaam, achternaam en leeftijd naar de server via de methode POST
// gegevens
$HOTE = "localhost";
$PORT = 80;
$URL = "/exemples-web/web_03.php";
list($prenom, $nom, $age) = array("jean-paul", "de la hûche", 45);
// verbinding met de webserver
$connexion = fsockopen($HOTE, $PORT);
// terugkeren bij fout
if (!$connexion) {
print "Echec de la connexion au site ($HOTE,$PORT) : $erreur";
exit;
}//if
// informatie naar de server verzenden PHP
// de gegevens worden gecodeerd
$infos = "prenom=" . urlencode(utf8_decode($prenom)) . "&nom=" . urlencode(utf8_decode($nom)) . "&age=" . urlencode("$age");
print "client : infos envoyées au serveur (POST) : $infos\n";
// verbinding maken met de URL $URL door parameters (POST) te posten
// de headers van het protocol HTTP moeten eindigen met een lege regel
// POST
fputs($connexion, "POST $URL HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion,"Connection: close\n");
// Content-type
fputs($connexion, "Content-type: application/x-www-form-urlencoded\n");
// Content-length
// de grootte (aantal tekens) van de informatie die verzonden gaat worden, wordt verzonden
fputs($connexion, "Content-length: " . strlen($infos) . "\n");
// er wordt een lege regel verzonden
fputs($connexion, "\n");
// de gegevens worden verzonden
fputs($connexion, $infos);
// De server zal nu reageren op het kanaal $connexion. Hij zal al
// zijn gegevens en sluit vervolgens het kanaal. De client leest alles wat binnenkomt van $connexion
// totdat het kanaal wordt gesloten
while ($ligne = fgets($connexion, 1000))
print "$ligne";
// sluit de client op zijn beurt de verbinding af
fclose($connexion);
Opmerkingen
- regel 7: de URL van de webservice waarmee de client POST verbinding gaat maken. Deze webservice wordt straks beschreven.
- regel 8: de parameters die naar de webservice moeten worden verzonden
- regel 10: verbinding met de webserver
- regel 18: codering van de parameters die naar de webservice moeten worden verzonden
- regel 23: Http-commando POST
- regel 25: HTTP-commando Host
- regel 27: HTTP-commando Connection
- regel 29: Http-commando Content-type. We zijn deze header HTTP al eerder tegengekomen. Deze is aanwezig telkens wanneer een document wordt verzonden. Een webserver die een HTML-document verzendt, gebruikt de header HTTP
Als er onopgemaakte tekst wordt verzonden, wordt de header HTTP gebruikt
Onze client POST verstuurt een document dat bestaat uit tekst in de vorm param1=val1¶m2=val2&.... Dit type document heeft het type application/x-www-form-urlencoded. We zullen niet uitleggen waarom, omdat we dan zouden moeten uitleggen wat een webformulier is.
- regel 32: Content-length-commando. We zijn deze header HTTP al eerder tegengekomen. Deze is aanwezig telkens wanneer een document wordt verzonden. Hij geeft het aantal bytes van het document aan.
- regel 34: de lege regel die het einde van de headers aangeeft HTTP
- regel 36: het verzenden van de parameters
- regels 40-41: het lezen van het volledige antwoord van de server
- regel 43: het afsluiten van de verbinding
10.2.4. De server (web_03)
De webservice [web_03] doet hetzelfde als de webservice [web_02]. Hij leest de parameters die door de client POST zijn verzonden en stuurt deze terug naar de client. De code is als volgt:
<?php
// foutafhandeling
ini_set("display_errors", "off");
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// de server haalt de door de client verzonden informatie op
// hier voornaam=P&achternaam=N&leeftijd=A
// deze gegevens zijn automatisch beschikbaar in de variabelen
// $_POST['prenom'], $_POST['nom'], $_POST['age']
// en worden teruggestuurd naar de client
// parameters verzonden naar de server
$prenom = isset($_POST['prenom']) ? $_POST['prenom'] : "";
$nom = isset($_POST['nom']) ? $_POST['nom'] : "";
$age = isset($_POST['age']) ? $_POST['age'] : "";
// antwoord aan de klant
$réponse = "informations reçues du client [" .
utf8_encode(htmlspecialchars($prenom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($nom, ENT_QUOTES)) .
"," . utf8_encode(htmlspecialchars($age, ENT_QUOTES)) . "]\n";
print $réponse;
Opmerkingen
- regels 14-16: de parameters die door een client POST worden verzonden, komen beschikbaar in de array $_POST voor de webservice die ze ontvangt.
- regel 6: header HTTP Content-Type. Het is opmerkelijk dat in de headers HTTP de header HTTP Content-Length ontbreekt, die de grootte aangeeft van het document dat naar de client wordt teruggestuurd. We hebben gezien dat de webserver standaard HTTP-headers verstuurt. De header Content-Length maakt daar deel van uit.
Resultaten
Zodra het serverscript in NetBeans is geschreven, is het onmiddellijk beschikbaar via de Apache-server van WampServer. Laten we niet vergeten dat dit via de configuratie wordt bereikt (zie paragraaf 10). We starten de client die de server opvraagt en ontvangen dan het volgende antwoord:
- regels 2-10: het antwoord van de server
- regels 2-8: de HTTP-headers
- regel 10: het document
- regel 6: de header HTTP Content-Length. Aangezien deze header niet door het serverscript is gegenereerd, is hij dus door de webserver gegenereerd.
- regel 8: de enige header die door het serverscript is gegenereerd
10.3. Ophalen van de omgevingsvariabelen van de server WEB
Een serverscript wordt uitgevoerd in een webomgeving waarvan het de details kent. Deze omgeving is opgeslagen in het woordenboek $_SERVER. We schrijven eerst een servertoepassing die de inhoud van dit woordenboek naar haar clients verstuurt.
10.3.1. De server (web_04)
<?php
// foutafhandeling
ini_set("display_errors", "off");
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// de lijst met variabelen die beschikbaar zijn in de serveromgeving wordt teruggestuurd naar de client
foreach ($_SERVER as $clé => $valeur) {
print "[$clé,$valeur]\n";
}
- De (sleutel, waarde)-paren uit het woordenboek $_SERVER worden naar de clients verzonden.
Het resultaat wanneer de client een webbrowser is, is als volgt:
Hieronder volgt de betekenis van enkele variabelen (voor Windows; onder Linux zouden deze anders zijn):
CMDE vertegenwoordigt de header HTTP die door de client is verzonden. We hebben toegang tot al deze headers. | |
het pad naar de uitvoerbare bestanden op de machine waarop het serverscript wordt uitgevoerd | |
het pad naar de DOS-opdrachtinterpreter | |
de extensies van de uitvoerbare bestanden | |
de Windows-installatiemap | |
de handtekening van de webserver. Hier niets. | |
het type webserver | |
de internetnaam van de webserver | |
de luisterpoort van de webserver | |
het adres IP van de webserver | |
het adres IP van de client. In dit geval bevond de client zich op dezelfde machine als de server. | |
de communicatiepoort van de client | |
de root van de boomstructuur van de documenten die door de webserver worden aangeboden | |
het e-mailadres van de beheerder van de webserver | |
het volledige pad naar het serverprogramma | |
de versie van het protocol HTTP dat door de webserver wordt gebruikt | |
de HTTP-volgorde die door de client wordt gebruikt. Er zijn er vier: GET, POST, PUT, DELETE | |
de parameters die worden meegestuurd met een opdracht GET /url?parameters | |
de door de klant aangevraagde URL. Als de browser de URL http://machine[:port]/uri aanvraagt, krijgen we REQUEST_URI=uri | |
$_SERVER['SCRIPT_FILENAME']=$_SERVER['DOCUMENT_ROOT'].$_SERVER['SCRIPT_NAME'] |
10.3.2. De client (client1_web_04)
De client geeft gewoon alles weer wat de server hem stuurt.
<?php
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_04.php";
// verbinding tot stand brengen op poort 80 van $HOTE
$connexion = fsockopen($HOTE, $PORT);
// fout?
if (!$connexion) {
print "Erreur : $erreur\n";
exit;
}
// verbinding maken met de webserver via URL
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion,"Connection: close\n");
// lege regel
fputs($connexion,"\n");
// de server zal nu reageren op het kanaal $connexion. Hij zal al
// zijn gegevens versturen en vervolgens het kanaal sluiten. De client leest dus alles wat binnenkomt van $connexion
// totdat het kanaal wordt gesloten
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
}//terwijl
// de client op zijn beurt de verbinding verbreekt
fclose($connexion);
// einde
exit;
Resultaten
10.4. Sessiebeheer WEB
In de voorgaande client/server-voorbeelden werkte het als volgt:
- de client opent een verbinding met poort 80 van de webserver
- de client verzendt de tekstreeks: HTTP-headers, lege regel, [document]
- als antwoord stuurt de server een reeks van hetzelfde type
- de server verbreekt de verbinding met de client
- de client verbreekt de verbinding met de server
Als dezelfde client kort daarna een nieuw verzoek naar de webserver stuurt, wordt er een nieuwe verbinding tot stand gebracht tussen de client en de server. De server kan niet weten of de client die verbinding maakt al eerder is geweest of dat dit een eerste verzoek is. Tussen twee verbindingen door „vergeet“ de server zijn client. Om deze reden wordt gezegd dat het protocol HTTP een stateloos protocol is. Toch is het nuttig dat de server zijn klanten onthoudt. Als een applicatie bijvoorbeeld beveiligd is, stuurt de klant een gebruikersnaam en wachtwoord naar de server om zich te identificeren. Als de server zijn klant tussen twee verbindingen ‘vergeet’, moet de klant zich bij elke nieuwe verbinding opnieuw identificeren, wat onhaalbaar is.
Om een klant te kunnen volgen, gaat de server als volgt te werk: bij een eerste verzoek van een klant neemt hij in zijn antwoord een identificatiecode op die de klant vervolgens bij elk nieuw verzoek naar de server moet terugsturen. Dankzij deze identificatiecode, die voor elke klant uniek is, kan de server een klant herkennen. Hij kan dan een geheugen voor deze klant beheren in de vorm van een bestand dat uniek is gekoppeld aan de identificatiecode van de klant.
Technisch gezien verloopt dit als volgt:
- in het antwoord aan een nieuwe klant voegt de server de header HTTP Set-Cookie: MotClé=Identificatiecode toe. Dit gebeurt alleen bij het eerste verzoek.
- Bij zijn volgende verzoeken zal de klant zijn identificatiecode terugsturen via de header HTTP Cookie: MotClé=Identificatiecode, zodat de server hem kan herkennen.
Je kunt je afvragen hoe de server weet of hij te maken heeft met een nieuwe klant of met een klant die al eerder is geweest. Dit wordt aangegeven door de aanwezigheid van de header HTTP Cookie in de HTTP-headers van de klant. Bij een nieuwe klant ontbreekt deze header.
Het geheel van verbindingen van een bepaalde klant wordt een sessie genoemd.
10.4.1. Het configuratiebestand
Om ervoor te zorgen dat het sessiebeheer correct werkt met PHP, moet worden gecontroleerd of het correct is geconfigureerd. Onder Windows is het configuratiebestand PHP.ini. Afhankelijk van de uitvoeringscontext (console, web) moet het configuratiebestand [PHP.ini] in verschillende mappen worden gezocht. Om deze te achterhalen, gebruikt u het volgende script:
Op regel 4 geeft de functie phpinfo informatie over de interpreter PHP die het script uitvoert. Deze functie geeft met name het pad naar het gebruikte configuratiebestand [PHP.ini].
In een console-omgeving krijgt men een resultaat dat er ongeveer als volgt uitziet:
regel 2: het hoofdconfiguratiebestand is c:\windows\PHP.ini
regel 3: een secundair configuratiebestand is C:\serveursSGBD\wamp21\bin\PHP\php5.3.5\PHP.ini. Hiermee kunnen bepaalde configuratieopties van het hoofdconfiguratiebestand worden gewijzigd.
In een webomgeving krijg je het volgende resultaat:
Het secundaire configuratiebestand is hier niet hetzelfde als in de console-omgeving. We gaan dit laatste bekijken. In dit bestand vinden we een sectie ‘session’:
- regel 1: de gegevens van een klantsessie worden opgeslagen in een bestand
- regel 3: de map waarin de sessiegegevens worden opgeslagen. Als deze map niet bestaat, wordt er geen fout gemeld en werkt het sessiebeheer niet.
- regels 4-5: geven aan dat de sessie-ID wordt beheerd door de HTTP-headers Set-Cookie en Cookie
- regel 6: de header Set-Cookie heeft de vorm Set-Cookie: PHPSESSID=identifiant_de_session
- regel 7: er wordt niet automatisch een clientsessie gestart. Het serverscript moet deze expliciet aanvragen met de instructie session_start().
10.4.2. Server 1 (web_05)
Het beheer van de sessie-ID verloopt transparant voor een webservice. Deze ID wordt beheerd door de webserver. Een webservice heeft toegang tot de sessie van de klant via de instructie session_start(). Vanaf dat moment kan de webservice gegevens lezen en schrijven in de sessie van de klant via het woordenboek $_SESSION. De volgende code toont het sessiebeheer van drie tellers.
<?php
// foutafhandeling
ini_set("display_errors", "off");
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// een sessie openen
session_start();
// er worden 3 variabelen in de sessie geplaatst
if (!isset($_SESSION['N1'])) {
$_SESSION['N1'] = 0;
}
if (!isset($_SESSION['N2'])) {
$_SESSION['N2'] = 10;
}
if (!isset($_SESSION['N3'])) {
$_SESSION['N3'] = 100;
}
// de 3 variabelen worden verhoogd
$_SESSION['N1']++;
$_SESSION['N2']++;
$_SESSION['N3']++;
// informatie naar de client verzenden
print "N1=".$_SESSION['N1']."\n";
print "N2=".$_SESSION['N2']."\n";
print "N3=".$_SESSION['N3']."\n";
// einde van de sessie
session_close();
- regel 9: starten van een klantsessie
- regels 11-13: de tabel $_SESSION is een woordenboek met (sleutel, waarde)-paren. De gegevens die in dit woordenboek worden opgeslagen, blijven behouden tijdens opeenvolgende verzoeken van dezelfde klant. Dit is het geheugen van de klant op de server.
- regels 11-19: als de drie tellers N1, N2, N3 niet in de sessie staan, worden ze daarin geplaatst.
- regels 21-23: ze worden met één verhoogd
- regels 25-27: hun waarde wordt naar de client verzonden
In de klant-serverrelatie hangt het beheer van de klantsessie op de server af van beide partijen, de klant en de server:
- de server is verantwoordelijk voor het verzenden van een identificatiecode naar de client bij diens eerste verzoek
- de client moet deze identificatiecode bij elk nieuw verzoek terugsturen. Als hij dat niet doet, zal de server aannemen dat het om een nieuwe client gaat en een nieuwe identificatiecode genereren voor een nieuwe sessie.
Resultaten
We gebruiken een webbrowser als client. Standaard (in feite door de configuratie) stuurt deze de sessie-ID's die de server hem toestuurt, inderdaad terug naar de server. Naarmate de verzoeken vorderen, ontvangt de browser de drie tellers die door de server worden verzonden en ziet hij dat hun waarden toenemen.
 |
- naar [1], het eerste verzoek aan de webservice [web_05]
- in [2]; het derde verzoek laat zien dat de tellers inderdaad zijn opgeteld. De waarden van de tellers worden inderdaad bij elk verzoek onthouden.
Laten we Firebug gebruiken om de HTTP-headers te bekijken die tussen de server en de client worden uitgewisseld. We sluiten Firefox om de huidige sessie met de server te beëindigen, openen het opnieuw en activeren Firebug. We vragen de service |web_05] op:
 |
Hierboven zien we de sessie-ID die door de server is verzonden in zijn antwoord op het eerste verzoek van de client. Deze maakt gebruik van de header HTTP Set-Cookie.
Laten we een nieuw verzoek doen door de pagina in de webbrowser te verversen (F5):
 |
Hierboven vallen twee dingen op:
- de webbrowser stuurt de sessie-ID terug met de header HTTP Cookie.
- in zijn antwoord neemt de webservice deze identificatiecode niet meer op. Het is nu de taak van de client om deze bij elk verzoek mee te sturen.
10.4.3. Klant 1 (client1_web_05)
We schrijven nu een clientscript op basis van het vorige serverscript. Bij het beheer van de sessie moet het zich gedragen als een webbrowser:
- In het antwoord van de server op zijn eerste verzoek moet hij de sessie-ID vinden die de server hem toestuurt. Hij weet dat hij deze zal vinden in de header HTTP Set-Cookie.
- Bij elk van zijn volgende verzoeken moet hij de ontvangen identificatiecode naar de server terugsturen. Dit doet hij met de header HTTP Cookie.
De code van de klant is als volgt:
<?php
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_05.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
list($erreur, $cookie, $N1, $N2, $N3) = connecte($HOTE, $PORT, $urlServeur, $cookie);
print "----------------------------\n";
print "client(erreur,cookie,N1,N2,N3)=[$erreur,$cookie,$N1,$N2,$N3]\n";
print "----------------------------\n";
}
// einde
exit;
function connecte($HOTE, $PORT, $urlServeur, $cookie) {
// verbindt de klant met ($HOTE,$PORT,$urlServeur)
// verzendt de cookie $cookie als deze niet leeg is
// geeft alle regels weer die als antwoord zijn ontvangen
// opent een verbinding op poort 80 van $HOTE
$connexion = fsockopen($HOTE, $PORT);
// fout?
if (!$connexion)
return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
// verbinding maken met $urlserveur
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion, "Connection: close\n");
// de cookie wordt verzonden als deze niet leeg is
if ($cookie) {
fputs($connexion, "Cookie: $cookie\n");
}//if
// stuur een lege regel
fputs($connexion, "\n");
// het antwoord van de webserver wordt weergegeven
// en zorg ervoor dat de eventuele cookie en de waarden van de Ni worden opgehaald
$N = "";
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
// cookie – alleen bij het eerste antwoord
if (!$cookie) {
if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
$cookie = $champs[1];
}
}
// waarde van N1
if (preg_match("/^N1=(.*?)\s*$/", $ligne, $champs))
$N1 = $champs[1];
// waarde van N2
if (preg_match("/^N2=(.*?)\s*$/", $ligne, $champs))
$N2 = $champs[1];
// waarde van N3
if (preg_match("/^N3=(.*?)\s*$/", $ligne, $champs))
$N3 = $champs[1];
}//terwijl
// de verbinding wordt verbroken
fclose($connexion);
// terug
return array("", $cookie, $N1, $N2, $N3);
}
Opmerkingen
- regels 3-16: het hoofdprogramma
- regels 18-67: de functie connecte
- regels 9-14: de client roept de server vijf keer aan en geeft de opeenvolgende waarden weer van de tellers N1, N2 en N3. Als de sessie correct wordt beheerd, zouden deze tellers bij elk nieuw verzoek met 1 moeten worden verhoogd.
- regel 10: de functie connecte gebruikt de parameters $HOTE, $PORT en $urlServeur om de client met de webservice te verbinden. De parameter $cookie vertegenwoordigt de sessie-ID. Bij de eerste aanroep is dit de lege tekenreeks. Bij de volgende aanroepen is dit de sessie-ID die door de server is verzonden als antwoord op de eerste aanroep van de client. De functie connecte retourneert als resultaten de waarden van de drie tellers $N1, $N2, $N3, de sessie-ID $cookie en een eventuele foutmelding $erreur.
- regel 18: de functie connecte heeft de kenmerken van een klassieke HTTP-client. We bespreken alleen de nieuwe functies.
- regels 30-40: verzending van de HTTP-headers.
- regels 36-38: als de sessie-ID bekend is, wordt deze naar de server verzonden
- regels 44-66: verwerking van alle door de server verzonden tekstregels
- regels 47-51: als de sessie-ID nog niet is opgehaald, wordt deze uit de header HTTP Set-Cookie opgehaald met behulp van een reguliere expressie.
- regels 53-54: de teller N1 wordt eveneens verkregen via een reguliere expressie
- regels 56-57, 59-60: hetzelfde geldt voor de tellers N2 en N3
- regel 63: de verbinding met de server wordt verbroken.
- regel 65: de resultaten worden teruggestuurd in de vorm van een tabel.
Resultaten
De uitvoering van het clientscript leidt tot de volgende weergave in de NetBeans-console:
- regel 5: in zijn eerste antwoord stuurt de server de sessie-ID mee. In de volgende antwoorden stuurt hij deze niet meer mee.
- Het is duidelijk te zien dat de webserver de waarden (N1,N2,N3) behoudt tijdens de verzoeken van de client. Dit wordt sessiebeheer genoemd.
De twee volgende voorbeelden laten zien dat je ook de waarden van een array of een object kunt opslaan.
10.4.4. Server 2 (web_06)
Het volgende serverscript laat zien dat je een array of een dictionary in de sessie kunt opslaan.
<?php
// foutafhandeling
ini_set("display_errors", "off");
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// er wordt een sessie geopend
session_start();
// een array en een woordenboek opslaan
// de array initialiseren of wijzigen
if (isset($_SESSION['tableau'])) {
for ($i = 0; $i < count($_SESSION['tableau']); $i++) {
$_SESSION['tableau'][$i]++;
}
} else {
for ($i = 0; $i < 10; $i++) {
$_SESSION['tableau'][$i] = $i * 10;
}
}
// het woordenboek wordt geïnitialiseerd of gewijzigd
if (isset($_SESSION['dico'])) {
foreach (array_keys($_SESSION['dico']) as $clé) {
$_SESSION['dico'][$clé]++;
}
} else {
$_SESSION['dico'] = array("zéro" => 0, "dix" => 10, "vingt" => 20);
}
// informatie naar de klant verzenden
print "tableau=" . join(",", $_SESSION['tableau']) . "\n";
print "dico=";
foreach ($_SESSION['dico'] as $clé => $valeur) {
print "($clé,$valeur) ";
}
print "\n";
Opmerkingen
- regels 17-19: een array wordt in eerste instantie in de sessie opgeslagen als deze daar nog niet in staat
- regels 12-15: als deze er al in staat, worden de elementen met 1 verhoogd
- regel 27: een woordenboek met numerieke waarden wordt in de sessie opgeslagen als het daar nog niet in staat
- regels 22-25: als het er al in staat, worden de numerieke waarden met 1 verhoogd
- regels 30-35: de array en het woordenboek worden naar de klant verzonden
10.4.5. De client 2 (client1_web_06)
<?php
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_06.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
connecte($HOTE, $PORT, $urlServeur, $cookie);
}
// einde
exit;
function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
// verbindt de klant met ($HOTE,$PORT,$urlServeur)
// verzendt de cookie $cookie als deze niet leeg is
// geeft alle regels weer die als antwoord zijn ontvangen
// de cookie wordt doorverwezen om te worden gedeeld tussen
// het aangeroepen programma en het aanroepende programma
// een verbinding openen op poort $PORT van $HOTE
$connexion = fsockopen($HOTE, $PORT);
// fout?
if (!$connexion)
return array("erreur lors de la connexion au serveur ($HOTE, $PORT)");
// de headers van het protocol HTTP moeten eindigen met een lege regel
// GET
fputs($connexion, "GET $urlServeur HTTP/1.1\n");
// Host
fputs($connexion, "Host: localhost\n");
// Verbinding
fputs($connexion, "Connection: close\n");
// de cookie wordt verzonden als deze niet leeg is
if ($cookie) {
fputs($connexion, "Cookie: $cookie\n");
}
// een lege regel verzenden
fputs($connexion, "\n");
// het antwoord van de webserver wordt weergegeven
// en zorg ervoor dat de eventuele cookie wordt opgehaald
while ($ligne = fgets($connexion, 1000)) {
print "$ligne";
// cookie – alleen bij het eerste antwoord
if (!$cookie) {
if (preg_match("/^Set-Cookie: (.*?)\s*$/", $ligne, $champs)) {
$cookie = $champs[1];
}
}
}
// de verbinding wordt verbroken
fclose($connexion);
// terug
return "";
}
De code van de klant is vergelijkbaar met de code van de klant die al is toegelicht.
Resultaten
10.4.6. Server 3 (web_07)
Het volgende serverscript laat zien dat je een object in een sessie kunt plaatsen.
<?php
// foutafhandeling
ini_set("display_errors", "off");
// header UTF-8
header("Content-Type: text/plain; charset=utf-8");
// een sessie wordt geopend
session_start();
// een Personne-object initialiseren of wijzigen
if (isset($_SESSION['personne'])) {
$personne = $_SESSION['personne'];
// de leeftijd wordt verhoogd
$personne->setAge($personne->getAge() + 1);
} else {
// de persoon wordt gedefinieerd
$_SESSION['personne'] = new Personne("paul", "langévin", 10);
}
// weergave aan de klant
print "personne=".$_SESSION['personne']."\n";
// einde
exit;
// ----------------------------------------------------------------
class Personne {
// attributen van de klasse
private $prénom;
private $nom;
private $âge;
// getters en setters
public function getPrénom() {
return $this->prénom;
}
public function getNom() {
return $this->nom;
}
public function getAge() {
return $this->âge;
}
public function setPrénom($prénom) {
$this->prénom = $prénom;
}
public function setNom($nom) {
$this->nom = $nom;
}
public function setAge($age) {
$this->âge = $age;
}
// constructor
function __construct($prénom, $nom, $âge) {
// we gaan via de set-methoden
$this->setPrénom($prénom);
$this->setNom($nom);
$this->setAge($âge);
}
// methode toString
function __toString() {
return "[$this->prénom,$this->nom,$this->âge]";
}
}
Opmerkingen
- regel 17: er wordt een object van het type Personne in de sessie geplaatst als het daar nog niet in staat.
- regels 11-15: als het er al in staat, wordt de leeftijd ervan met 1 verhoogd
- regel 20: het object van het type Personne wordt naar de client verzonden.
10.4.7. De client 3 (client1_web_07)
<?php
// gegevens
$HOTE = "localhost";
$PORT = 80;
$urlServeur = "/exemples-web/web_07.php";
// tests
$cookie = "";
for ($i = 0; $i < 5; $i++) {
connecte($HOTE, $PORT, $urlServeur, $cookie);
}//if
// einde
exit;
function connecte($HOTE, $PORT, $urlServeur, &$cookie) {
...
}
Opmerkingen
- regel 15: de functie connecte is identiek aan die van het vorige clientscript
Resultaten