数据库类连接到我的其他类

Question

I'm following MVC OOP structure and I'm wondering how a decent database class would look like. The purpose of the database class is to for other classes to either call its method or extend it.

This is how my connection.php looks now

 <?php

$db = new mysqli('localhost', 'root', '', 'audiologiska_kliniken');

if($db->connect_errno > 0){
    die('Ett fel inträffade [' . $db->connect_error . ']');
}

This a database class I started.

    <?php
include 'C:/wamp/www/mvc/include/connect.php';
class Database
{
    private $host;
    private $user;
    private $password;
    private $database;
    function __construct{
      //  if(file_exists($filename)) {include '';}
        //else throw new exception("Error!");

        $this->host=$host;
        $this->user=$user;
        $this->password=$password;
        $this->database=$database;

        $this->connect();
    }
    private function connect()
    {//Connect to the server
        if(!mysqli_connect($this->host, $this->user, $this->password, $this->database))

It doesn't look good I know, but I really don't know how to improve it further. I would appreciate some suggestions from you guys

Answer 1

As Halcyon has mentioned, look into autoloading with namespaces, with composer or your own spl_autoload function.

You should do some investigation into other design patterns also.

It's common for a singleton pattern to be used to prevent loading multiple database connections per request/response cycle.

That way every time you need your database connection you could do something like

$db = DB::getInstance();

which would return you a new instance of the connection if nothing has previously created the class, or the existing connection.

It might also be a good idea to stop the instance being cloned by people, by implementing the __cloned magic method like so:

public function __clone() {
    throw new Exception("Can't clone a singleton");
}

People argue however that singletons are bad because they introduce global state and tight coupling into an application. This makes them hard to test. An alternative would be to look at maybe using a Service, which is something that is meant to be global within the application.

http://fabien.potencier.org/article/11/what-is-dependency-injection Symfony have a good method of using services and a dependency injection container.

Laravel also has a great example of a dependency injection container in the IoC Container. It's a single class that manages class resolution. The framework calls its Services ServiceProviders.

Working like this has many strengths, such as ease of testing and loose coupling between objects in your application.

https://github.com/illuminate/database in particular Connection.php and ConnectionResolver.php are a way of implementing database connections. Connection.php represents the actual connection, which is created each time with a factory pattern, and the ConnectionResolver is smart enough to handle multiple connections. For inspiration :)