conectar - conexion a base de datos php mysqli

¿Cuál es el mejor método para obtener una conexión/objeto de base de datos en una función en PHP?

Question

Algunas de las opciones son:

$connection = {my db connection/object};
function PassedIn($connection) { ... }
function PassedByReference(&$connection) { ... }
function UsingGlobal() {
global $connection;
...
}

Por lo tanto, pasó, pasó por referencia o utilizando global. Estoy pensando en funciones que solo se usan en 1 proyecto que solo tendrá 1 conexión de base de datos. Si hay múltiples conexiones, definitivamente pasa o pasa por referencia.

Estoy thining pasado por referencia no es necesario cuando estás en PHP5 utilizando un objeto, por lo que luego pasó o utilizando global son las 2 posibilidades.

La razón por la que estoy preguntando es porque me estoy cansando de poner siempre $ conexión en los parámetros de mi función.

Answer 1

Intenta diseñar tu código de forma orientada a objetos. Los métodos que usan la base de datos se deben agrupar en una clase, y la instancia de la clase debe contener la conexión de la base de datos como una variable de clase. De esta forma, la conexión de la base de datos está disponible para las funciones que lo necesitan, pero no es global.

class MyClass {
protected $_db;
public function __construct($db)
{
$this->_db = $db;
}
public function doSomething()
{
$this->_db->query(...);
}
}

Answer 2

Ninguna de las anteriores.

Todas las funciones de mysql toman opcionalmente el argumento de conexión a la base de datos. Si deja fuera ese argumento, se asume la última conexión por mysql_connect ().

Answer 3

Veo que mucha gente ha sugerido algún tipo de variable estática.

Básicamente, hay muy poca diferencia entre una variable global y una variable estática. Excepto por la sintaxis, tienen exactamente las mismas características. Como tal, no obtiene nada en absoluto, reemplazando una variable global con una variable estática. En la mayoría de los ejemplos, hay un nivel de desacoplamiento en el que la variable estática no se refiere directamente, sino a través de un método estático (por ejemplo, un registro único o estático). Si bien es un poco mejor, esto todavía tiene los problemas de un alcance global. Si alguna vez necesitas usar más de una conexión de base de datos en tu aplicación, estás jodido. Si alguna vez quiere saber qué partes de su código tienen efectos secundarios, debe inspeccionar manualmente la implementación. Eso no es algo que hará o romperá su aplicación, pero hará que sea más difícil de mantener.

Propongo que elijas entre uno de:

• Pase la instancia como argumentos a las funciones que lo necesitan. Este es de lejos el más simple, y tiene todos los beneficios de un alcance estrecho, pero puede ser bastante difícil de manejar. También es una fuente para introducir dependencias, ya que algunas partes de tu código pueden terminar convirtiéndose en intermediarios. Si eso sucede, ve a ...

• Coloque la instancia en el alcance del objeto, que tiene el método que lo necesita. P.ej. si el método Foo->doStuff() necesita una conexión de base de datos, páselo en el constructor de Foo y Foo->doStuff() como una variable de instancia protegida en Foo . Todavía puede terminar con algunos de los problemas de pasar el método, pero generalmente es un problema menor con los constructores difíciles de manejar que con los métodos. Si su aplicación es lo suficientemente grande, puede usar un contenedor de inyección de dependencia para automatizar esto.

Answer 4

function usingFunc() {
$connection = getConnection();
...
}
function getConnection() {
static $connectionObject = null;
if ($connectionObject == null) {
$connectionObject = connectFoo("whatever","connection","method","you","choose");
}
return $connectionObject;
}

De esta forma, el $ connectionObject estático se conserva entre llamadas getConnection.

Answer 5

Utilizo una clase Singleton ResourceManager para manejar cosas como conexiones de bases de datos y configuraciones de configuración a través de una aplicación completa:

class ResourceManager {
private static $DB;
private static $Config;
public static function get($resource, $options = false) {
if (property_exists(''ResourceManager'', $resource)) {
if (empty(self::$$resource)) {
self::_init_resource($resource, $options);
}
if (!empty(self::$$resource)) {
return self::$$resource;
}
}
return null;
}
private static function _init_resource($resource, $options = null) {
if ($resource == ''DB'') {
$dsn = ''mysql:host=localhost'';
$username = ''my_username'';
$password = ''p4ssw0rd'';
try {
self::$DB = new PDO($dsn, $username, $password);
} catch (PDOException $e) {
echo ''Connection failed: '' . $e->getMessage();
}
} elseif (class_exists($resource) && property_exists(''ResourceManager'', $resource)) {
self::$$resource = new $resource($options);
}
}
}

Y luego en funciones / objetos / donde sea:

function doDBThingy() {
$db = ResourceManager::get(''DB'');
if ($db) {
$stmt = $db->prepare(''SELECT * FROM `table`'');
etc...
}
}

Lo uso para almacenar mensajes, mensajes de error y advertencias, así como también variables globales. Hay una pregunta interesante sobre cuándo usar este tipo de clase.

Answer 6

Mi consejo es evitar global en la mayor parte del código: es peligroso, difícil de rastrear y te morderá.

La forma en que lo haría es tener una función llamada getDB () que puede estar a nivel de clase mediante una inyección de constructor o estática dentro de una clase común.

Entonces el código se convierte

class SomeClass {
protected $dbc;
public function __construct($db) {
$this->dbc = $db;
}
public function getDB() {
return $this->dbc;
}
function read_something() {
$db = getDB();
$db->query();
}
}

o usando una clase compartida común.

function read_something() {
$db = System::getDB();
$db->query();
}

No importa qué tan elegante sea el diseño del sistema, siempre hay algunos elementos que son necesariamente de alcance global (como DB, Session, Config), y prefiero mantenerlos como métodos estáticos en mi clase System .

Hacer que cada clase requiera una conexión a través del constructor es la mejor manera de hacerlo; mejor me refiero a la más confiable y aislada.

Sin embargo, tenga en cuenta que el uso de una clase compartida común para hacer esto puede afectar la capacidad de aislar completamente los objetos que lo utilizan y también la capacidad de realizar pruebas unitarias en estos objetos.