Hallo,

Ik ben sinds kort begonnen met OOP en heb een mysql database class gemaakt, Nu zou ik graag willen weten of ik de goede kant op ga en wat ik nog zou kunnen verbeteren kwa coderen en beveiligen.

Oop is toch wat moeilijker dan ik had gedacht. :P

<?php

//Database class
class db
{

private $hostname;
private $username;
private $password;
private $database;
private $connect;
private $select_db;

public function __construct()
{
$this->hostname = 'xxxxx';
$this->username = 'xxxxx';
$this->password = 'xxxxx';
$this->database = 'xxxxx';

}

public function open_connection()
{
try
{
$this->connect = mysql_connect($this->hostname,$this->username,$this->password);
$this->select_db = mysql_select_db($this->database);
}
catch(exception $e)
{
return $e;
}
}

public function close_connection()
{
try
{
mysql_close($this->connect);
}
catch(exeption $e)
{
return $e;
}
}

public function query($sql)
{
try
{
$this->open_connection();
$sql = mysql_query($sql);
}
catch(exception $e)
{
return $e;
}
$this->close_connection();
return $sql;
}
}

?>
Hoi Robin Peters

Leuk dat je bezig bent met het Object Georienteerd Programmeren. Dat dit moeilijk is zal ik niet ontkennen. Het is een heel andere denkwijze dan het ´normale´ programmeren. Opzich ben je goed op weg maar ik vraag me af of in elke method een try catch handig is.

Bij het maken van een applicatie is het uitdenken van deze een belangrijke stap. Ook vooruit denken speelt hierin een grote rol.

Je kunt nu maar 1 connectie met een bepaald soort database maken. Als je later wilt overgaan op een ander soort database moet je de code zodanig veranderen dat je beter een nieuwe kunt maken. Het is goed om hiervoor een voorziening voor te treffen, en een module te maken waarin het niet uitmaakt welke database type je gebruikt. Bekijk het script hieronder eens..

<?php

/**
* @package database
*
* @author Niels Kieviet <[email protected]>
* @version $Revision v1.00$
* @copyright Copyright (c) 2010, Niels Kieviet
*/

/*
* Database interface
*/
interface database
{
/**
* Make connection with the database
*
* @param string $dbHost
* @param string $dbUser
* @param string $dbPass
* @param string $dbName
*/
public function connect( $db_host, $db_user, $db_pass, $db_name );

/**
* Run a Query
*/
public function query( $query );
}

/**
* DatabaseResult interface
*/
interface databaseResult
{
/**
* @return array
*/
public function fetch_assoc();

/**
* @return array
*/
public function fetch_all();

/**
* @return int
*/
public function rows();

/**
* @return int
*/
public function last_id();
}

/**
* Database exception class.
*/
class databaseException extends Exception
{
}

/**
* MySQL class.
*/
class MySQL implements database
{

/**
* @var array
*/
private $connection;

/**
* Make connection with a MySQL database
*/
public function connect( $db_host, $db_user, $db_pass, $db_name )
{
if( !$this->connection = mysql_connect( $db_host, $db_user, $db_pass, $db_name ) ) {
throw new databaseException( 'Connection with MySQL database failed' );
}
if( !mysql_select_db( $db_name, $this->connection ) ) {
throw new databaseException( 'Select database failed' );
}
}

/**
* Run Query
*
* @return MySQLResult
*/
public function query( $query )
{
$result = mysql_query( $query, $this->connection );
if( !$result ) {
throw new databaseException( mysql_error() );
}
return new MySQLResult( $result );
}
}

/**
* MySQLResult class.
*/
class MySQLResult implements databaseResult
{
/**
* @var array
*/
private $result;

/**
* Constructor.
*
* @param handler $result
*/
public function __construct( $result )
{
$this->$result = $result;
}

/**
* @return array
*/
public function fetch_assoc()
{
return mysql_fetch_assoc( $this->result );
}

/**
* @return array
*/
public function fetch_all()
{
$result = array();
while( $row = $this->fetch_assoc() ) {
$result[] = $row;
}
return $result;
}

/**
* @return int
*/
public function rows()
{
return mysql_num_rows( $this->result );
}

/**
* @return int
*/
public function last_id()
{
return mysql_insert_id( );
}
}
?>

Je zou ook eens naar PDO kunnen kijken. Dan ben je gelijk van het probleem af.

PS: Er kunnen fouten in zitten ik heb hem niet getest..
Waarom MySQL gebruiken en niet gewoon [php]mysqli[/php]? (Als je dan toch OOP gaat programmeren)
Ja inderdaad Chris, al zou ik eerder voor PDO gaan.
Ten eerste bedankt voor reacties!

Ik denk dat ik inderdaad verder ga met PDO, en dan op de onderstaande manier (Bron: PHPhulp)

<?php
try
{
$db = new PDO('mysql:host=localhost;dbname=test','user','password');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$sql = "SELECT naam FROM bestaat_niet";
$results = $db->query($sql);

foreach($results as $row)
{
echo $row['naam'].'<br>';
}
}
catch(PDOException $e)
{
echo '<pre>';
echo 'Regelnummer: '.$e->getLine().'<br>';
echo 'Bestand: '.$e->getFile().'<br>';
echo 'Foutmelding: '.$e->getMessage().'<br>';
echo '</pre>';
}
?>
Op welke manier zou je het anders doen dan?

Dit is gewoon DE manier om PDO te gebruiken...
Wat ik vaak doe is een singleton class bouwen en daarin gewoon een instantie van PDO teruggeven.


<?php

//Zo doe ik dat dan in mijn classes

class test{

private $db;

public function __construct(){
//doe iets;

$this->db = DB::getInstance('PDO');

$stmt = $this->db->prepare('...');
}


//meer functies.
}

?>
@Jurgen,

Het gebruikt van singletons wordt afgeraden omdat dit tegen de OOP regels is..
Oja? Vertel eens, waarom is dat niet toegestaan.

Mijn idee: Zonder OOP en dus objecten en classes kan je ook geen singletons hebben, dus singletons is ook een onderdeel van objecten e.d.

Reageren