Comparé à Cookie, Session est une session côté serveur, relativement sécurisée, et contrairement à Cookie, il n'y a pas de limite de longueur de stockage. Cet article présente brièvement l'utilisation de Session.
Étant donné que Session est stockée côté serveur sous forme de fichiers texte, il n'y a pas à craindre que les clients modifient le contenu de Session. En fait, pour les fichiers Session côté serveur, PHP modifie automatiquement les permissions de fichier, ne laissant que les permissions de lecture et d'écriture système, et ils ne peuvent pas être modifiés via FTP, ce qui est donc beaucoup plus sûr.
Pour les cookies, supposons que nous voulions vérifier si un utilisateur est connecté. Nous devons stocker le nom d'utilisateur et le mot de passe (éventuellement une chaîne chiffrée en md5) dans le cookie, et les vérifier à chaque requête de page. Si le nom d'utilisateur et le mot de passe sont stockés dans la base de données, une requête à la base de données doit être exécutée à chaque fois, ce qui impose une charge inutile à la base de données. Parce que nous ne pouvons pas vérifier une seule fois. Pourquoi ? Parce que les informations du cookie client peuvent être modifiées. Supposons que vous stockiez une variable $admin pour indiquer si l'utilisateur est connecté. Lorsque $admin est vrai, cela signifie connecté ; lorsque faux, cela signifie non connecté. Après la première vérification réussie, vous stockez $admin égal à vrai dans le cookie, et la prochaine fois aucune vérification n'est nécessaire. Est-ce correct ? Faux. Si quelqu'un falsifie une variable $admin avec la valeur vrai, n'obtiendrait-il pas immédiatement les droits d'administration ? C'est très peu sûr.
La session est différente. La session est stockée côté serveur, donc les utilisateurs distants ne peuvent pas modifier le contenu des fichiers de session. Par conséquent, nous pouvons simplement stocker une variable $admin pour déterminer si l'utilisateur est connecté. Après la première vérification réussie, définissez $admin sur vrai. Ensuite, vérifiez si cette valeur est vraie ; sinon, redirigez vers la page de connexion. Cela peut réduire de nombreuses opérations sur la base de données. Cela réduit également l'insécurité liée à la transmission du mot de passe à chaque fois pour la vérification par cookie (la vérification par session ne doit être transmise qu'une seule fois, si vous n'utilisez pas le protocole de sécurité SSL). Même si le mot de passe est chiffré en md5, il peut facilement être intercepté.
Bien sûr, utiliser une session présente de nombreux autres avantages, comme un contrôle facile et la possibilité de personnaliser le stockage selon l'utilisateur (par exemple, stocker dans une base de données). Je n'entrerai pas dans les détails ici.
La Session doit-elle être configurée dans php.ini ? Généralement non, car tout le monde n'a pas la permission de modifier php.ini. Le chemin de stockage par défaut de la Session est le dossier temporaire système du serveur. Nous pouvons le personnaliser pour qu'elle soit stockée dans notre propre dossier, ce que je présenterai plus tard.
Introduisons maintenant comment créer une Session. C'est vraiment très simple.
Démarrer une Session et créer une variable $admin :
Exemple
// Démarrer la Session
session_start();
// Déclarer une variable nommée admin et lui affecter une valeur vide.
$_SESSION["admin"] = null;
?>
Si vous utilisez Session, ou si ce fichier PHP doit appeler des variables de Session, vous devez la démarrer avant d'appeler Session, en utilisant la fonction session_start(). Vous n'avez rien d'autre à configurer ; PHP crée automatiquement le fichier de Session.
Après avoir exécuté ce programme, nous pouvons aller dans le dossier temporaire système pour trouver ce fichier de Session. En général, le nom du fichier ressemble à : sess_4c83638b3b0dbf65583181c2f89168ec, suivi d'une chaîne aléatoire encodée de 32 bits. Ouvrez-le avec un éditeur et examinez son contenu :
admin|N;
En général, le contenu a la structure suivante :
variable name|type:length:value;
Chaque variable est séparée par un point-virgule. Certaines parties peuvent être omises, comme la longueur et le type.
Regardons le programme de vérification, en supposant que la base de données stocke le nom d'utilisateur et le mot de passe chiffré en md5 :
Code du fichier login.php
// Après la soumission du formulaire...
$posts = $_POST;
// Supprimer certains caractères d'espacement
foreach ($posts as $key => $value) {
$posts[$key] = trim($value);
}
$password = md5($posts["password"]);
$username = $posts["username"];
$query = "SELECT `username` FROM `user` WHERE `password` = '$password' AND `username` = '$username'";
// Obtenir le résultat de la requête
$userInfo = $DB->getRow($query);
if (!empty($userInfo)) {
// Démarrer la session après la réussite de la vérification
session_start();
// Enregistrer la variable admin pour une connexion réussie et lui attribuer true
$_SESSION["admin"] = true;
} else {
die("Nom d'utilisateur ou mot de passe invalide");
}
?>
Sur les pages qui nécessitent une authentification de l'utilisateur, nous démarrons la session et déterminons si l'utilisateur est connecté :
Exemple
// Prévenir les risques de sécurité liés aux variables globales
$admin = false;
// Démarrer la session, cette étape est essentielle
session_start();
// Déterminer si l'utilisateur est connecté
if (isset($_SESSION["admin"]) && $_SESSION["admin"] === true) {
echo "Vous êtes connecté avec succès";
} else {
// La vérification a échoué, définir $_SESSION["admin"] à false
$_SESSION["admin"] = false;
die("Vous n'avez pas la permission d'accéder");
}
?>
N'est-ce pas simple ? Considérez simplement $_SESSION comme un tableau stocké côté serveur. Chaque variable que nous enregistrons est une clé du tableau, exactement comme lorsqu'on utilise un tableau.
Que faire si vous voulez vous déconnecter du système ? Il suffit de détruire la session.
Exemple
session_start();
// Cette méthode détruit une variable précédemment enregistrée
unset($_SESSION['admin']);
// Cette méthode détruit tout le fichier de session
session_destroy();
?>
Une session peut-elle définir une durée de vie comme un cookie ? Avec les sessions, faut-il complètement abandonner les cookies ? Je dirais que l'utilisation d'une session en combinaison avec un cookie est la plus pratique.
Comment la session identifie-t-elle l'utilisateur client ? Il est identifié par l'ID de session. Qu'est-ce qu'un ID de session ? C'est le nom du fichier de cette session. L'ID de session est généré de manière aléatoire, garantissant ainsi l'unicité et le caractère aléatoire, et assurant la sécurité de la session. Généralement, si la durée de vie de la session n'est pas définie, l'ID de session est stocké en mémoire. Après la fermeture du navigateur, l'ID est automatiquement effacé, et après avoir demandé à nouveau la page, un nouvel ID de session est enregistré.
Si le client ne désactive pas les cookies, le cookie joue le rôle de stocker l'ID de session et la durée de vie de la session lorsque la session est démarrée.
Définissons manuellement la durée de vie de la session :
Exemple
session_start();
// Enregistrer pour un jour
$lifeTime = 24 * 3600;
setcookie(session_name(), session_id(), time() + $lifeTime, "/");
?>
En fait, Session fournit également une fonction session_set_cookie_params(); pour définir la durée de vie de la Session. Cette fonction doit être appelée avant l'appel de la fonction session_start() :
Exemple
// Enregistrer pour un jour
$lifeTime = 24 * 3600;
session_set_cookie_params($lifeTime);
session_start();
$_SESSION["admin"] = true;
?>
Si le client utilise IE 6.0, la fonction session_set_cookie_params(); peut avoir des problèmes pour définir le Cookie, donc nous appelons toujours manuellement la fonction setcookie pour créer le cookie.
Que se passe-t-il si le client désactive les Cookie ? Il n'y a pas de solution ; toutes les durées de vie sont liées au processus du navigateur. Dès que le navigateur est fermé, vous devez réenregistrer la Session lorsque vous demandez à nouveau la page. Alors, comment transmettre l'ID de Session ? Transmettez-le via l'URL ou via un formulaire masqué. PHP envoie automatiquement l'ID de Session à l'URL. L'URL ressemble à : http://www.test.cn/index.php?PHPSESSID= bba5b2a240a77e5b44cfa01d49cf9669, où le paramètre PHPSESSID dans l'URL est l'ID de Session. Nous pouvons utiliser $_GET pour obtenir cette valeur, ce qui permet de transmettre l'ID de Session entre les pages.
Exemple
// Enregistrer pour un jour
$lifeTime = 24 * 3600;
// Obtenir le nom de la Session actuelle, la valeur par défaut est PHPSESSID
$sessionName = session_name();
// Obtenir l'ID de Session
$sessionID = $_GET[$sessionName];
// Utilisez session_id() pour définir l'ID de session obtenu
session_id($sessionID);
session_set_cookie_params($lifeTime);
session_start();
$_SESSION['admin'] = true;
?>
Pour les hôtes virtuels, si toutes les sessions des utilisateurs sont enregistrées dans le dossier temporaire du système, cela entraînera des difficultés de maintenance et réduira la sécurité. Nous pouvons définir manuellement le chemin d'enregistrement des fichiers de session. session_save_path() fournit une telle fonction. Nous pouvons pointer le répertoire de stockage des sessions vers un dossier inaccessible via le Web. Bien sûr, le dossier doit disposer des permissions de lecture et d'écriture.
Exemple
// Définir un répertoire de stockage
$savePath = './session_save_dir/';
// Enregistrer pour un jour
$lifeTime = 24 * 3600;
session_save_path($savePath);
session_set_cookie_params($lifeTime);
session_start();
$_SESSION['admin'] = true;
?>
Comme la fonction session_set_cookie_params();, la fonction session_save_path() doit également être appelée avant la fonction session_start().
Nous pouvons également stocker des tableaux et des objets dans la session. La manipulation des tableaux n'est pas différente de celle des variables ordinaires, mais lors de l'enregistrement d'objets, PHP sérialisera automatiquement (aussi appelé sérialisation) les objets, puis les enregistrera dans la session. L'exemple suivant illustre cela :
Code du fichier person.php
class person {
var $age;
function output() {
echo $this->age;
}
function setAge($age) {
$this->age = $age;
}
}
?>
code du fichier setage.php
session_start();
require_once 'person.php';
$person = new person();
$person->setAge(21);
$_SESSION['person'] = $person;
echo '<a href='output.php'>cliquez ici pour afficher l’âge</a>';
?>
code du fichier output.php
// Définir la fonction de rappel pour garantir que l’objet est reconstruit.
ini_set('unserialize_callback_func', 'mycallback');
function mycallback($classname) {
include_once $classname . '.php';
}
session_start();
$person = $_SESSION['person'];
// Sortie 21
$person->output();
?>
Lorsque nous exécutons le fichier setage.php, nous appelons la méthode setage(), définissons l'âge à 21 et sérialisons cet état avant de l'enregistrer dans la Session (PHP effectuera automatiquement cette conversion). Lorsque nous allons dans output.php, pour afficher cette valeur, nous devons désérialiser l'objet enregistré juste avant. Et comme la désérialisation nécessite d'instancier une classe non définie, nous avons défini une fonction de rappel pour inclure automatiquement le fichier de classe person.php, afin que l'objet soit reconstruit, et que la valeur actuelle de l'âge soit obtenue comme 21, puis la méthode output() est appelée pour afficher cette valeur.
De plus, nous pouvons également utiliser la fonction session_set_save_handler pour personnaliser la façon dont la Session est appelée.
Adresse d'origine : https://www.cnblogs.com/happyforev1/articles/1645916.html