La domanda è piuttosto popolare tra i principianti e sarebbe sbagliato non dedicarvi un articolo a parte. Come con utilizzando PHP creare una connessione al database? Dirò subito che gli strumenti PHP sono abbastanza sufficienti per lavorare a pieno titolo con i database e interagire con MySQL. Ora proviamo a connetterci!
Di cosa hai bisogno per connettere PHP a MySQL?
1. DBMS installato e creato database funzionante. Ad esempio, in MySQL (Cosa sono DBMS e MySQL?).2. Account utente per MySQL con diritti appropriati (quali sono i diritti e i privilegi in MySQL?)
3. Di conseguenza, un server con PHP installato
Se non completi uno di questi passaggi, non sarai in grado di connetterti.
Algoritmo per l'interazione tra PHP e MySQL
1. Connessione al database2. Invio di una richiesta e ricezione del risultato
3. (Preferito) Chiusura della connessione
Ora ci colleghiamo al database usando PHP:
Codice PHP
$db = mysql_connect("localhost", "Admin", "pass"); // dati dell'utente
mysql_select_db("baseName",$db); // seleziona a quale database connettersi
?>
Come puoi vedere, per la connessione vengono specificati quattro parametri:
1.
Nome host. In molti casi è sufficiente specificare localhost (sullo stesso hosting).
2.
Il nome dell'utente che hai registrato per utilizzare MySQL.
3.
La password dell'utente che hai registrato per utilizzare MySQL.
4.
Il nome del database a cui vogliamo connetterci. Di conseguenza, l'utente da noi specificato deve avere i diritti per lavorare in questo database.
Di conseguenza, se qualcosa viene indicato in modo errato, non accadrà nulla di criminale, ma molto probabilmente vedrai un errore. Ma siamo ottimisti, diciamo che hai inserito tutto correttamente.
Altro tipo di connessione:
Codice PHP
$host="localhost"; /*ospite*/
$utente="amministratore"; /*Nome utente*/
$password="12345"; /*Password utente*/
$db="nomebase"; /*Nome del database*/
Mysql_connect($host, $utente, $password); /*Connettiti al server*/
mysql_select_db($db); /*Connettersi a un database sul server*/
?>
Qui creo visivamente variabili con dati di esempio per l'utente e l'host, quindi creo una connessione.
Come interrompere (chiudere) una connessione a un database in PHP?
Ci sono casi in cui le informazioni di connessione sono specificate in modo errato. In questo caso lo script continua l'elaborazione del file PHP e produce un certo numero di errori e avvisi sulla pagina. Per questi casi, suggerisco di utilizzare un gestore di errori durante la connessione al database. Se la connessione non va a buon fine riceverai un avviso che ti dirà in quale fase si trova il problema:Codice PHP
$utente="amministratore";
$password="12345";
$db="nomebase";
// se si è verificato un errore
mysql_connect($host, $utente, $password) or die("Il server MySQL non è disponibile!".mysql_error());
mysql_select_db($db) or die("Nessuna connessione al database."mysql_error());
?>
È anche molto importante che lo sviluppo dello scenario si interrompa, il che ti salverà da molti dati errati.
Congratulazioni! Ora sai come connetterti a un database in PHP e chiudere la connessione!
Grazie per l'attenzione!
Dopo aver installato il server MySQL, puoi connetterti ad esso solo dalla stessa macchina. Ciò è stato fatto per motivi di sicurezza del sistema, poiché nella maggior parte dei casi MySQL viene utilizzato sul Web e lì, in rari casi, il server Web e il server del database sono separati.
Nel segmento aziendale, è più corretto utilizzare 1 server per tutte le attività simili. È stupido mantenere MySQL con un database su ogni server che potrebbe averne bisogno. Pertanto, deve essere presente un server database su cui è installato il numero richiesto di database per attività diverse.
A proposito, sul Web, un server database e un server web sono separati solo nei casi in cui la potenza di un server non è sufficiente. Noleggi un server dedicato e ospiti il database su di esso. Vorrei chiarire che è ragionevole farlo solo all'interno di un DC.
Consenti la connessione a MySQL da remoto
Nel file di configurazione di MySQL stesso c'è un parametro indirizzo-bind che è responsabile di ciò, quindi:
- aprire file di configurazione per la modifica:
sudo nano /etc/mysql/my.cnf - commentare la riga:
# indirizzo di associazione = 127.0.0.1 - riavvia MySQL:
sudo servizio mysql riavvio
Commentare questa riga equivale ad assegnare un indirizzo IP 0.0.0.0 , ovvero consentire a tutti di connettersi. Non è possibile specificare 2 indirizzi IP in questa riga. Se è necessario limitare la connessione al server MySQL, è necessario utilizzare le funzionalità di iptables.
Ora puoi connetterti al server del database tramite un client telnet, ma per entrare è necessario account, a cui è consentito connettersi non solo da localhost. Per fare ciò è necessario connettersi a MySQL dal server stesso e creare il seguente utente:
Mysql -u root -p
E crea un utente con il comando:
CONCEDI TUTTI I PRIVILEGI SU *.* A "new_user"@"remote_address" IDENTIFICATO DA "password" CON OPZIONE GRANT;
Questa riga crea un utente con diritti illimitati, il che non è del tutto corretto da fare. È più corretto limitare il più possibile l'accesso dell'utente che si connette da remoto. Quindi il comando potrebbe assomigliare a questo:
CONCEDI SELEZIONE,INSERISCI,ELIMINA,AGGIORNA,CREA,ALTERA SU "nome_database".* A "nuovo_utente"@"indirizzo_remoto" IDENTIFICATO DA "password" CON L'OPZIONE CONCESSIONE;
Con questo comando, abbiamo limitato i permessi dell'utente a un solo database e le azioni con esso.
Un elenco completo di tutti i diritti che possono essere specificati per un utente:
- TUTTI I PRIVILEGI– tutti i diritti sull'oggetto specificato, ad eccezione dell'assegnazione dei diritti su questo oggetto;
- CREARE– il diritto di creare un tavolo;
- ALTERARE– diritto di cambio tavolo;
- GOCCIOLARE– il diritto di distruggere il tavolo;
- TABELLE BLOCCATE– il diritto di bloccare il tavolo;
- CREARE TABELLE TEMPORANEE– il diritto di creare tabelle temporanee;
- CREA ROUTINE– il diritto di creare procedure e funzioni memorizzate;
- ALTERARE LA ROUTINE– il diritto di modificare o distruggere procedure e funzioni memorizzate;
- CREA VISTA– il diritto di creare una rappresentanza;
- GRILLETTO– il diritto di creare e distruggere i trigger;
- INDICE– diritti di creare e distruggere indici;
- ESEGUIRE– il diritto di eseguire procedure e funzioni memorizzate;
- EVENTO– il diritto di creare eventi;
- CREA UTENTE– diritti di creare, distruggere, rinominare un utente e rimuovere tutti i diritti. Nominato solo a livello globale;
- SELEZIONARE– diritto di campionamento;
- ELIMINARE– diritto alla cancellazione;
- INSERIRE– diritto di inserimento;
- AGGIORNAMENTO– diritto di aggiornamento;
- FILE– il diritto di utilizzare i comandi SELECT ... INTO OUTFILE e LOAD DATA INFILE;
- PROCESSO– il diritto di visualizzare tutti i processi utilizzando il comando SHOW PROCESSLIST;
- MOSTRA DATABASE– diritto di visione dell'elenco dei regimi;
- MOSTRA VISTA– il diritto di visualizzare l'elenco delle visualizzazioni;
- FERMARE– diritto alla chiusura.
In questo articolo di oggi parleremo della creazione di una connessione a un database e discuteremo quale opzione è meglio utilizzare procedurale o orientata agli oggetti. Per prima cosa diamo un'occhiata a quale livello siamo, se questo è il livello di un principiante assoluto, allora il mio consiglio, senza eccezioni, è di iniziare a utilizzare lo stile procedurale di connessione al database. In precedenza, ho scritto un articolo su questo argomento sul mio blog; per maggiori informazioni sullo stile procedurale di connessione a un database, leggi l'articolo: “Come connettersi a MySQL utilizzando PHP”. Se hai già una certa esperienza di lavoro con uno stile procedurale di connessione a un database, probabilmente, come me, hai semplicemente preso i miei progetti e li hai costretti a utilizzare un approccio orientato agli oggetti.
In un modo o nell'altro, analizzeremo ora le fasi della costruzione di una classe per creare una connessione al database Dati MySQL SU Linguaggio PHP. Avremo bisogno di due file PHP, in un file "metteremo" la classe per creare una connessione al database e nel secondo lavoreremo con questa classe.
Creiamo due file:
- indice.php;
- database.class.php;
Penso che non siamo più bambini piccoli e sappiamo cosa ci serve per lavorare con i file PHP. Web installato- Server Apache, PHP, DBMS MySQL e sa dove mettere questi file - (per coloro che non lo sanno o lo hanno dimenticato).
Inserisco il file in cui è archiviata la classe fascicolo separato e lo chiamo nel formato: nome classe.class.php e so cosa è memorizzato in questo file. Quando ci sono molte classi in un progetto, puoi perderti, quindi consiglio di denominare i file con le classi nel formato descritto sopra.
File database.class.php:
Diamo ora un'occhiata a cosa è stato creato questo passaggio. Utilizzando la parola chiave "class", il nome della classe - DataBase e le parentesi graffe, abbiamo creato il corpo della classe. Nella classe creata, abbiamo creato due proprietà, in $mConnect - dove viene archiviato il risultato della connessione al database e $mSelectDB - dove viene archiviato il risultato della selezione di un database. Potresti aver notato le parole chiave in ciascuna proprietà: pubblica e statica. Di cosa stanno parlando? Pubblico significa che la proprietà è accessibile dall'esterno della classe e statico rende possibile accedere o chiamare la proprietà senza creare un'istanza della classe, il che è molto spesso conveniente nel lavoro.
Aggiungiamo il metodo Connect() per creare una connessione al database:
".mysql_error()."
"; exit(); return false; ) // Restituisce il risultato return self::$mConnect; ) ) ?>- $host - indirizzo IP del server, su un PC locale è localhost;
- utente: nome utente del database;
- $pass - password dell'utente del database;
- $name - il nome del database a cui ci connettiamo;
La funzione mysql_connect() crea una connessione al database e memorizza il risultato dell'esecuzione in $mConnect. Successivamente viene effettuato un controllo con il costrutto IF: Se la connessione non ha avuto successo, visualizza un messaggio di errore... Altrimenti, PHP ignorerà il blocco IF e passerà alla selezione del database. La funzione mysql_select_db() seleziona il nome del database, se il database richiesto non esiste nel database, in questo caso il programma informerà l'utente di un errore. Se tutto ha esito positivo, la connessione al database restituirà return.
Aggiungi il metodo Close():
Siamo spiacenti, non siamo riusciti a connetterci al server MySQL
"; exit(); return false; ) // Prova a selezionare un database self::$mSelectDB = mysql_select_db($name, self::$mConnect); // Se il database non è selezionato, visualizza un messaggio di errore.. if( !self::$mSelectDB) ( echo "".mysql_error()."
"; exit(); return false; ) // Restituisce il risultato return self::$mConnect; ) // Il metodo chiude la connessione al database con la funzione statica pubblica Close() ( // Restituisce il risultato return mysql_close(self: :$mConnetti) ; ) ) ?>Il successivo e ultimo metodo di questa classe, Close(), chiude la connessione al database; la funzione mysql_close() chiude la connessione al server MySQL e restituisce il risultato.
File indice.php:
Utilizzando la funzione define(), abbiamo creato costanti per memorizzare i parametri di connessione al database. Require_once include la nostra classe DataBase nel file index.php.
Ricordiamolo parola chiave static, utilizzato nella classe DataBase nelle proprietà e nei metodi di questa classe. Questo ci dà la possibilità di accedere alle proprietà e ai metodi della classe usando "::" (due due punti). Il metodo DataBase::Connect(DB_SERVER, DB_USERNAME, DB_PASSWORD, DB_DATABASE) accetta 4 parametri: costanti create dalla funzione define(), che memorizzano informazioni sulla connessione al database. Se la connessione ha esito positivo, il metodo Connect() ci restituirà una connessione al database. Successivamente, saremo in grado di lavorare ed eseguire query sul database. Funzione mysql_query(): esegue una query sul database. La funzione mysql_fetch_assoc() elabora una serie di risultati della query e restituisce un array associativo. Il costrutto echo mostra la versione del server MySQL. Infine, il metodo DataBase::Close() chiuderà la connessione al database.
Utilizzando PHP...
Creare una connessione a un database in PHP in diversi modi:
1) il vecchio modo per connettersi a MySQL:
$conn=mysql_connect($db_hostname, $db_username, $db_password) or die ("Nessuna connessione al server");
mysql_select_db($db_database,$conn) or die ("No, non è stato possibile connettersi al database");
Spiegazioni delle variabili di seguito.
Vengono utilizzate le seguenti funzioni:
- mysql_connect()- connettersi al server;
- mysql_select_db()- connettersi al database;
Allo stesso tempo, controlliamo costantemente la presenza di errori in questo modo: o moriamo ("L'errore è questo e quello"); - tradotto come o morire con questo o quell'errore - per scoprire immediatamente dov'è l'errore.
config.php
// variabili per la connessione al database
$host = "localhost"; /ospite
$nomeutente = "root"; // password per la connessione al database
$password = ""; // password per la connessione al database - on computer locale potrebbe avere un valore vuoto.
$database_name = "mio-dolgi"; // nome del database
// vecchio modo di connettersi al database
mysql_connect($host, $nomeutente, $password) or die("Impossibile connettersi, creare connessione");
// seleziona il database. Se c'è un errore, output
mysql_select_db($database_name) o die(mysql_error());
indice.php
require_once "config.php";
$risultato = mysql_query("SELECT Nome, Money FROM Dolg ORDER BY Money DESC LIMIT 5") or die(mysql_error());
";
while ($riga = mysql_fetch_assoc($risultato)) (
";
}
mysql_free_result($risultato);
// Chiude la connessione
mysql_close();
2) Uno stile procedurale più progressivo: connessione al database utilizzando mysqli:
Questo metodo:
- più conveniente;
- fino a 40 volte più veloce;
- maggiore sicurezza;
- ci sono nuove caratteristiche e funzioni;
Un esempio di connessione ad un database in PHP con una selezione da una tabella
config.php
// connessioni al database
$link = mysqli_connect("localhost", "nome utente", "password", "nome-database"); // qui inseriamo direttamente i tuoi dati: nome utente, password e nome del database, il primo campo è solitamente localhost
// errore di connessione in uscita
se (!$collegamento) (
echo "Errore di connessione al database. Codice errore: " . mysqli_connect_error();
Uscita;
}
Nota: mysqli è usato ovunque, non mysql!!!
indice.php
require_once "config.php";
// Esegue la richiesta. Se c'è un errore, lo visualizziamo
se ($risultato = mysqli_query($collegamento,"SELEZIONA Nome, Denaro DA Debito ORDINA PER Denaro DESC LIMITE 5")) (
Eco "A chi devo in ordine decrescente:
";
// Recupero dei risultati della query
mentre ($riga = mysqli_fetch_assoc($risultato)) (
echo $riga["Nome"] . "con debito". $riga["Denaro"] . " rubli.
";
}
// liberare la memoria utilizzata
mysqli_free_result($risultato);
// Chiude la connessione
mysqli_close($collegamento);
}
Come puoi vedere, alcuni punti sono cambiati (in corsivo).
3) Metodo orientato agli oggetti per connettersi a un database MySQL - utilizzando metodi e classi:
Contro: Più complesso e meno suscettibile agli errori.
Pro: brevità e comodità per programmatori esperti.
$conn = new mysqli($db_hostname, $db_username, $db_password, $db_database);
if($conn->connect_errno)(
die($conn->connect_error);
) else (echo "La connessione al database è stata stabilita con successo";)
qui, in linea di principio, tutto è intuitivo:
- $db_hostname lo è ospite(principalmente host locale),
- $db_database - nome del DB;
- $db_username e $db_password - rispettivamente nome utente e password!
Un esempio di connessione ad un database in stile php OOP con campionamento da una tabella
config.php
// connessioni al database
$mysqli = new mysqli("localhost", "nome utente", "password", "nome-database"); // qui inseriamo direttamente i tuoi dati: nome utente, password e nome del database, il primo campo è solitamente localhost
// errore di connessione in uscita
if ($mysqli->connect_error) (
die ("Errore di connessione DB: (" . $mysqli->connect_errno . ") " . mysqli_connect_error) ;
}
Nota: mysqli è usato ovunque, non mysql!!! e a differenza del metodo precedente compaiono le frecce “->” che indicano che si tratta di uno stile OOP.
indice.php
require_once "config.php";
// Esegue la richiesta. Se c'è un errore, lo visualizziamo
se ($risultato = $ mysqli->query("SELEZIONA Nome, Denaro DA Debito ORDINA PER Denaro DESC LIMITE 5")) (
Eco "A chi devo in ordine decrescente:
";
// Recupero dei risultati della query
while ($riga = $risultato-> fetch_assoc()) {
echo $riga["Nome"] . "con debito". $riga["Denaro"] . " rubli.
";
}
// liberare la memoria utilizzata
$risultato->chiudi();
// Chiude la connessione
$mysqli->chiudi();
}
Il tuo compito è trovare le differenze.
4) Comunicazione con il database tramite PDO:
Quando ci si connette a un database MySQL, vengono utilizzate espressioni preparate (utilizzando il metodo prepare) e di conseguenza, maggiore sicurezza e aumento notevolmente delle prestazioni.
file di configurazione dal metodo precedente! - lo stesso
indice.php
// Stile PDO per la comunicazione con MySQL
if ($stmt = $mysqli->prepare("SELEZIONA Nome, Voney DA Dolg ORDINA PER Money< ? LIMIT 5")) {
$stmt->bind_param("i", $summa);
$ somma = 100000;
//avvia l'esecuzione
$stmt->esegui();
// Dichiarazione di variabili per valori preparati
$stmt->bind_result($col1, $col2);
Eco "A chi devo in ordine decrescente:
";
// Recupero dei risultati della query
while ($stmt->fetch()) (
echo $col1 . "con debito". $col2 . " rubli.
";
}
// liberare la memoria utilizzata
$stmt->chiudi();
// Chiude la connessione
$mysqli->chiudi();
Come puoi vedere, questo è molto più complicato e devi studiare PDO: questo è un argomento separato.
3 metodi per connettersi a MySQL con PHP con esempi di codice
Per iniziare a utilizzare il database MySQL, devi prima capire come connetterti dal tuo programma PHP personalizzato (script) a questo stesso database MySQL.
Questo articolo descrive i tre metodi seguenti, insieme ai corrispondenti esempi di codice PHP che spiegano come connettersi al database da PHP.
Per tutti gli esempi seguenti, ci collegheremo a un database MySQL esistente. Nota: tutto quanto spiegato qui funzionerà anche con MariaDB, proprio come MySQL.
1. Connessione a PHP utilizzando l'estensione mysqli
*mysqli significa MySQL migliorato
Crea il seguente file mysqli.php
connect_error) ( die("Errore: impossibile connettersi: " . $conn->connect_error); ) echo "Connesso al database.
"; $risultato = $conn->query("SELECT id FROM goroda"); echo "Numero di righe: $risultato->num_rows"; $risultato->close(); $conn->close(); ?> Nel codice sopra:
- mysqli - Questa funzione avvia una nuova connessione utilizzando l'estensione mysqli. La funzione accetta quattro argomenti:
- localhost è il nome dell'host su cui è in esecuzione il database MySQL
- nome: nome utente MySQL per connettersi
- pass - password per l'utente mysql
- db: database MySQL a cui connettersi.
- qvery - funzione Interrogazione MySQL. In questo esempio, selezioniamo la colonna id dal database della città.
- Infine, mostriamo nel risultato il numero di righe selezionate utilizzando la variabile num_rows. Chiudiamo anche sia il risultato che la variabile di connessione come mostrato sopra.
Connesso al database. Numero di righe: 6 2. Connetti da PHPMySQL Estensione DOP
*PDO sta per PHP Data Objects
Il driver PDO_MYSQL implementa l'interfaccia PDO fornita da PHP per connettersi dallo script PHP a un database MySQL.
Crea il seguente file mysql-pdo.php:
setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Connesso al database.
"; $sql = "SELEZIONA id FROM goroda"; print "Elenco degli id:
"; foreach ($conn->query($sql) as $riga) ( print $riga["id"] . "
- "; ) $conn = null; ) catch(PDOException $err) ( echo "Errore: impossibile connettersi: " . $err->getMessage(); ) ?> In quanto sopra:
- new PDO: creerà un nuovo oggetto PDO che accetterà i seguenti tre argomenti:
- stringa di connessione mysql: sarà nel formato “mysql:host=localhost;dbname=db”. Nell'esempio sopra il db è in esecuzione su localhost e ci stiamo connettendo al database db.
- Nome utente MySQL per connettersi
- Password utente MySQL Variabile $sql - crea interrogazione SQL
- che vuoi eseguire. In questo esempio, selezioniamo la colonna id dalla tabella delle città.
- interrogazione($sql). Qui stiamo eseguendo la query SQL che abbiamo appena creato.
- per ciascuno. Qui iteriamo il risultato del comando query precedente e lo memorizziamo nella variabile $row e quindi lo restituiamo utilizzando echo.
Connesso al database. ID elenco: 1 2 3 4 5 6 3. Connessione da PHP utilizzando funzioni mysql obsolete
Utilizza questo metodo solo se ne usi di più vecchia versione PHP e per qualche motivo non è possibile aggiornarlo nuova versione. Si consiglia di utilizzare il metodo n. 2 e il metodo n. 3 mostrati sopra invece di questo metodo. Ho incluso questo metodo solo come riferimento e non come raccomandazione per l'uso.
Questa particolare estensione è stata deprecata da Versioni PHP 5.5. Ma a partire da PHP 7.0 questo non funzionerà nemmeno poiché è stato rimosso. A partire da PHP 5.5, quando si utilizzano queste funzioni, verrà generato un errore E_DEPRECATED.
Crea un file mysql.php:
"; $risultato = mysql_query("SELECT id FROM goroda"); $riga = mysql_fetch_row($risultato); echo "id 1: ", $riga, "
\n"; mysql_close($conn); ?> Nell'esempio sopra:
- La funzione mysql_connect accetta tre argomenti:
- il nome dell'host su cui è in esecuzione il database MySQL;
- Nome utente MySQL per connettersi;
- password per l'utente mysql. Qui si connette al database MySQL che è in esecuzione sul server locale utilizzando il nome utente e la relativa password.
- funzione mysql_select_db. Come suggerisce il nome, seleziona il database a cui desideri connetterti. Equivalente al comando "usa". In questo esempio ci stiamo connettendo a un database db.
- Funzione mysql_query: utilizzata per specificare la query MySQL. In questo esempio, selezioniamo la colonna id dal database della città. mysql_fetch_row. Utilizza questa funzione per estrarre righe dalla query SQL che abbiamo appena creato.
- Infine, chiudi la connessione utilizzando il comando mysql_close come mostrato sopra.
Connesso al database. id 1: 1 Ecco come puoi connetterti a MySQL. Ripeto, è meglio utilizzare i primi due metodi; O