Estensione della classe MySQLi
Domanda
Voglio essere in grado di creare classi che estendono la classe MySQLi per eseguire tutte le sue query SQL.
$mysql = new mysqli('localhost', 'root', 'password', 'database') or die('error connecting to the database');
Non so come farlo senza globalizzare l'oggetto $ mysql da usare negli altri miei metodi o classi.
class Blog {
public function comment() {
global $mysql;
//rest here
}
}
Qualsiasi aiuto sarebbe apprezzato.
Grazie.
Soluzione
Il mio suggerimento è di creare una classe Singleton DataAccess, creare un'istanza di quella classe in un file di configurazione globale e chiamarla nella tua classe Blog come $ query = DataAccess :: query (" SELECT * FROM blog WHERE id = " ;. $ id)
Guarda nel modello Singleton, è un modello di progettazione abbastanza facile da capire. Perfetto per questa situazione.
La tua classe DataAccess può avere diversi metodi come query
, fetchAssoc
, numRows
, checkUniqueValue
, transactionStart
, transactionCommit
, transactionRollback
ecc. ecc. Quelle funzioni potrebbero anche essere configurate come un'interfaccia che viene implementata dalla classe DataAccess. In questo modo è possibile estendere facilmente la classe DataAccess per più sistemi di gestione del database.
Quanto sopra descrive praticamente il mio modello DataAccess.
Altri suggerimenti
Stavo lavorando a qualcosa di simile. Sono contento di questa classe singleton che incapsula il login al database.
<?php
class db extends mysqli
{
protected static $instance;
protected static $options = array();
private function __construct() {
$o = self::$options;
// turn of error reporting
mysqli_report(MYSQLI_REPORT_OFF);
// connect to database
@parent::__construct(isset($o['host']) ? $o['host'] : 'localhost',
isset($o['user']) ? $o['user'] : 'root',
isset($o['pass']) ? $o['pass'] : '',
isset($o['dbname']) ? $o['dbname'] : 'world',
isset($o['port']) ? $o['port'] : 3306,
isset($o['sock']) ? $o['sock'] : false );
// check if a connection established
if( mysqli_connect_errno() ) {
throw new exception(mysqli_connect_error(), mysqli_connect_errno());
}
}
public static function getInstance() {
if( !self::$instance ) {
self::$instance = new self();
}
return self::$instance;
}
public static function setOptions( array $opt ) {
self::$options = array_merge(self::$options, $opt);
}
public function query($query) {
if( !$this->real_query($query) ) {
throw new exception( $this->error, $this->errno );
}
$result = new mysqli_result($this);
return $result;
}
public function prepare($query) {
$stmt = new mysqli_stmt($this, $query);
return $stmt;
}
}
Per usare puoi avere qualcosa del genere:
<?php
require "db.class.php";
$sql = db::getInstance();
$result = $sql->query("select * from city");
/* Fetch the results of the query */
while( $row = $result->fetch_assoc() ){
printf("%s (%s)\n", $row['Name'], $row['Population']);
}
?>
Puoi usare la parola chiave extends di PHP solo per qualsiasi altra classe:
class MyCustomSql extends mysqli {
public function __construct($host, $user, $password, $database) {
parent::__construct($host, $user, $password, $database);
}
public function someOtherMethod() {
}
}
$sql = new MyCustomSql('localhost', 'root', 'password', 'database') or die('Cannot connect!');
o meglio usare l'aggregazione di oggetti invece dell'ereditarietà:
class MySqlManipulator {
private $db;
public function __construct($host, $user, $password, $database) {
$this->db = new mysqli($host, $user, $password, $database);
}
public function someOtherMethod() {
return $this->db->query("SELECT * FROM blah_blah");
}
}
$mysqlmanipulator = new MySqlManipulator('localhost', 'root', 'password', 'database') or die('Cannot connect!');
Il mio metodo standard consiste nel creare una classe singleton che funge da accessor del database e una classe base da cui tutto ciò che richiede tale accesso eredita.
class Base {
protected $db;
function __construct(){
$this->db= MyDBSingleton::get_link();
//any other "global" vars you might want
}
}
class myClass extends Base {
function __construct($var) {
parent::__construct();// runs Base constructor
$this->init($var);
}
function init($id) {
$id=(int) $id;
$this->db->query("SELECT * FROM mytable WHERE id=$id");
//etc.
}
}
Dai un'occhiata a PDO , che generano eccezioni per te catturare se una query fallisce. È ampiamente usato e testato, quindi non dovresti avere problemi a trovare soluzioni esistenti mentre lo usi.
Per iniettarlo nella classe del tuo blog:
class Blog {
private Dai un'occhiata a PDO , che generano eccezioni per te catturare se una query fallisce. È ampiamente usato e testato, quindi non dovresti avere problemi a trovare soluzioni esistenti mentre lo usi.
Per iniettarlo nella classe del tuo blog:
<*>db;
public function __construct(PDO $db) {
$this->_db = $db
}
public function comment() {
return $this->_db->query(/*something*/);
}
}