Pomoc - Szukaj - Użytkownicy - Kalendarz
Pełna wersja: AdoDB + __construct()
Forum PHP.pl > Forum > PHP > Object-oriented programming
Aztech
Pytanko: mam klasę a w niej wiadomo konstruktor. Czy tworzenie w nim połączenia z AdoDB jest dobrym pomysłem (by nie musieć się łączyć za każdym razem w wywołaniu metody update, create, alter, delete z bazą danych?


  1. <?php
  2.  
  3. include("adodb.inc.php");
  4.  
  5. class TUser {
  6.  
  7.  
  8. /*
  9. pola prywatne
  10. */
  11.  
  12. public function __construct() {
  13. $db = NewADOConnection('mysql');
  14. $db->Connect("localhost", "root", "password", "mydb");
  15. }
  16.  
  17. public function updateUser(){
  18. /*
  19. kod
  20. */
  21. $db->Execute(/* formuła na update */)
  22. }
  23.  
  24. public function createUser(){
  25. /*
  26. kod
  27. */
  28. $db->Execute(/* formuła na tworzenie usera */)
  29. }
  30.  
  31. public function deleteUser(){
  32. /*
  33. kod
  34. */
  35.  
  36. $db->Execute(/* formuła na usuwanie */)
  37. }
  38.  
  39. }
  40.  
  41. ?>
mike
Przechowywanie w polu prywatnym połączenia z bazą danych to bardzo dobry pomysł.

BTW:
Chyba zresztą każdy tak robi.
Aztech
raczej chodziło mi o to żeby nie robić czegoś takiego:

  1. <?php
  2.  
  3. include("adodb.inc.php");
  4.  
  5. class TUser {
  6.  
  7.  
  8. /*
  9. pola prywatne
  10. */
  11.  
  12. public function __construct() {
  13. /*
  14. kod
  15. */
  16. }
  17.  
  18. public function updateUser(){
  19. /*
  20. kod
  21. */
  22. $db = NewADOConnection('mysql');
  23. $db->Connect("localhost", "root", "password", "mydb");
  24. $db->Execute(/* formuła na update */)
  25. }
  26.  
  27. public function createUser(){
  28. /*
  29. kod
  30. */
  31. $db = NewADOConnection('mysql');
  32. $db->Connect("localhost", "root", "password", "mydb");
  33. $db->Execute(/* formuła na tworzenie usera */)
  34. }
  35.  
  36. public function deleteUser(){
  37. /*
  38. kod
  39. */
  40. $db = NewADOConnection('mysql');
  41. $db->Connect("localhost", "root", "password", "mydb");
  42. $db->Execute(/* formuła na usuwanie */)
  43. }
  44.  
  45. }
  46.  
  47.  
  48. ?>


zawsze można też:
  1. <?php
  2.  
  3. public function connect($db) {
  4. $db = NewADOConnection('mysql');
  5. $db->Connect("localhost", "root", "password", "mydb");
  6. }
  7.  
  8. ?>


i potem w miejsce
  1. <?php
  2.  
  3. $db = NewADOConnection('mysql');
  4. $db->Connect("localhost", "root", "password", "mydb");
  5.  
  6. ?>

dajemy
  1. <?php
  2.  
  3.  $this->connect($db);
  4.  
  5. ?>

więc pytanie, czy nie lepiej w konstruktorze a jeśli nie to dlaczego?
mike
W skrócie:
  1. <?php
  2.  
  3. include("adodb.inc.php");
  4.  
  5. class TUser {
  6.  
  7.  
  8. /*
  9. pola prywatne
  10. */
  11. private $db = null;
  12.  
  13. public function __construct() {
  14. $db = NewADOConnection('mysql');
  15. $this->db = $db->Connect("localhost", "root", "password", "mydb");
  16.  
  17. }
  18.  
  19. public function updateUser(){
  20. /*
  21. kod
  22. */
  23. $this->db->Execute(/* formuła na update */)
  24. }
  25.  
  26. public function createUser(){
  27. /*
  28. kod
  29. */
  30. $this->db->Execute(/* formuła na tworzenie usera */)
  31. }
  32.  
  33. public function deleteUser(){
  34. /*
  35. kod
  36. */
  37. $this->db->Execute(/* formuła na usuwanie */)
  38. }
  39.  
  40. }
  41.  
  42.  
  43. ?>
Aztech
Dzięki bardzo, właśnie o to mi chodziło, czy tak wolno.
EOT
ActivePlayer
a na moje oko tak najpoprawniej:

  1. <?php
  2.  
  3. include("adodb.inc.php");
  4.  
  5. class TUser {
  6.  
  7.  
  8. /*
  9. pola prywatne
  10. */
  11. private $db = null;
  12.  
  13. public function __construct(&$db) {
  14. $this->db = $db;
  15.  
  16. }
  17. //...
  18. }
  19. $db = NewADOConnection('mysql');
  20. $db->Connect("localhost", "root", "password", "mydb");
  21. $user = new TUser(&$db);
  22.  
  23. ?>


moglem cos z referencjami popaprac bo na oczka nie widze...
dr_bonzo
Dokładnie - w php5 obiekty przekazywane sa jako referencje -- wiec wszystkie '&' sa niepotrzebne. A "TUser(&$db);" to nawet dostaniesz warninga/notice'a.
krzysztof f.
Można też tak:

  1. <?php
  2. class TUser {
  3.  /**
  4. * Połączenie z bazą danych
  5. * @var Connection
  6. * @access protected
  7. * @static
  8. **/
  9.  protected static $oDbConn;
  10.  
  11.  /**
  12. * Konstruktor 
  13. *
  14. * Ustwienie obiektu połączenia z bazą danych
  15. *
  16. * @return TUser
  17. * @access public
  18. * @throws RegistryException
  19. * @throws SQLException 
  20. **/
  21.  public function __construct()
  22.  {
  23. try
  24. {
  25.  $this->oDbConn = ServiceLocator::getInstance()->getDbConn();
  26. }
  27. catch ( RegistryException $oE )
  28. {
  29.  throw $oE;
  30. }
  31. catch ( DbException $oE )
  32. {
  33.  throw $oE;
  34. }
  35.  }
  36. }
  37. ?>


Gdzie ServiceLocator http://java.sun.com/blueprints/corej2eepat...iceLocator.html to klasa odpowiedzialna za wyszukiwanie usług powszechnie używanych w obrębie całej palikacji. Możemy ją zaimplementować w najprostrzy sposób jako rejestr http://www.phppatterns.com/docs/design/the_registry
NuLL
Nie lepiej singleton :?:
  1. <?
  2. class costam
  3. {
  4. public function jakasMetoda()
  5. {
  6. $result=db::instance()->query("jakies zapytanie do sql-a");
  7. }
  8. }
  9. ?>
To jest wersja lo-fi głównej zawartości. Aby zobaczyć pełną wersję z większą zawartością, obrazkami i formatowaniem proszę kliknij tutaj.
Invision Power Board © 2001-2025 Invision Power Services, Inc.