Spøgsmål til klasser

Hej alle,

jeg er i gang med et mindre projekt og benytter mig af klasser.

Spg 1. Når jeg skal bruge database adgang i en klasse vil det bedste så være at oprette forbindelsen i konstruktøren og lukke forbindelsen i destruktøren?

Spg 2. Vil det mon være en fordel at benytte sig af Singleton i forbindelse med database håndtering?

Mvh Martin

Jeg vil sige ja til begge spørgsmål. Hvis du selv vil lave dine klasser, synes jeg at du har fat i den lange ende...

umiddelbart ville jeg sige nej til det første og ja til det andet.

Ville lave en DB klasse der er singleton, så skal alle klasser der skal bruge db access bruge den instancen af den klasser.

ville lave DB klassen så den ikke connectede i constructoren, men ved første query og disconnected i destructoren eller ved kald til en disconnect function.

Fordelen ved det er at du kun har en klasse der er direkte til DB, gør det formentlig lettere at skifte DB. Og du undgår at connect og disconnect op til flere gange på samme side lige efter hinanden.

Vil tilsidst lige sige at jeg ikke bruger en klasse selv, men derimod en samling af functioner, for at undgå at skulle sende instansen til alle andre klasser eller kalde den globabel variable af klassen.

Jeg laver mine klasser selv, for også at lære at blive mere OOP orienteret

Jeg har heldigvis kun en database jeg skal holde styr på Destructoren bliver den kaldt når det sidste element er blevet kørt eller? Kan nemlig ikke lige huske det.

Hvis du har tænkt dig at benytte mysql_connect skal du ikke bekymre dig om at lave formange forbindelser, for hvis du prøver at oprette den samme forbindelse 2 gange uden at give den den fjerde parameter, så benytter den samme forbindelse

På nuværende tidspunkt ser min klasse således ud

<?php
/**
 * Include libraries
 */
 require_once ('config.php');
 
/**
 * This class contains functions for handling mysql data
 *
 * @author Martin Askjær Kristensen
 * @copyright 2008 
 * @package MySQL
 * @version 1.0 
 */ 
class MySQL
{
	/**
	 * Private variables	 
	 */
	private $conn;	
	
	/**
	 * Constructor
	 * 
	 * @param string hostname hostname for mysql server
	 * @param string username username for mysql server
	 * @param string password password for mysql server
	 * @param string database database which contains your tables	 
	 */
	public function __construct($db_hostname = DB_HOST, $db_username = DB_USER, $password = DB_PASS, $database = DB_DATA)
	{
		$conn = @mysql_connect($hostname, $username, $password);
		
		if($this->isConnected())
			@mysql_select_db($database, $this->conn);
	}
	
	private function isConnected()
	{
		if($this->conn)
			return true;
		else
			return false;
	}
	
	/**
	 * Closes the mysql connection
	 */
	public function close()
	{
		if($this->isConnected())
		{
			@mysql_close($this->conn);
		}		
	}
	
	/**
	 * Counts the rows for the query
	 * 
	 * @param string sql The sql sentence you want to execute on the mysql server	 
	 */
	public function countRows($sql)
	{
		if($this->isConnected())		
		{
			$num = @mysql_num_rows($sql); 
			return $num;
		}
	}
	
	/**
	 * Fetches the dataarray from the query
	 * 
	 * @param string sql The sql sentence you want to execute on the mysql server
	 */
	public function fetchArray($sql)
	{
		if($this->isConnected())		
		{
			$array = @mysql_fetch_array($sql);
			return $array;
		}
	}
	
	/**
	 * Query executes the sql sentence on the server
	 * 
	 * @param string sql The sql sentence you want to execute on the mysql server	 
	 */
	public function query($sql)
	{
		if(!$this->isConnected())
		{
			if(get_magic_quotes_gpc())
				stripslashes($sql);	
			$sql = @ mysql_real_escape_string($sql, $this->conn);
			
			$query = @mysql_query($sql); 
			return $query;
		}
	}
}
?>

umiddelbart ville jeg sige nej til det første og ja til det andet.

Ville lave en DB klasse der er singleton, så skal alle klasser der skal bruge db access bruge den instancen af den klasser.

Der er vel intet i vejen for at lave en singleton med connect i construct

næh den eneste fordel jeg så ved det var at man kunne inkluder den i sin main fil og create den i sin main fil, men at man stadig kun connectede hvis man faktisk havde brug for det. Er efterfølgende kommet i tanke om at man jo bare kunne bede om instansen når man skal bruge den og hvis den ikke findes skulle den jo gerne autocreates

I princippet en singleton der laver en ny instans hvis den ikke eksister, hvor constructoren opretter forbindelsen.

Så det ville være noget i denne stil, lidt forsimplet

 <?php
 
 class MySQL
 {
     private $conn;
     private static $instance;
     
     private function MySQL()
     {
         $this->conn = mysql_connect(DB_HOST, DB_USER, DB_PASS) or die(mysql_error());
         mysql_select_db(DB_DATA, $this->conn) or die(mysql_error());
     }
     
     public static function getInstance()
     {
         if(!self::$instance instanceof self)
         {
             self::$instance = new self;
         }
         return self::$instance;
     }
 }
 
 ?>