Jaký je nejlepší způsob, jak snížit počet dotazů, když má třída DAO metody, které používají stejný výsledek?

Tato odpověď je závislá na aktuální struktuře dotazu, kde nejsou žádné podmínky

class CategoriaDAO extends PDOConnectionFactory
{
    /*DB Connection, static member since you only need one connection*/
    private static $dbConnection;

    /*Sql result set, static since there is not conditonal and only a single table used*/
    private static $resultSet;

    private static function getConnection()
    {
            /*Connect to mysql db, set CategoriaDAO::dbConnection; */
    }

    private static function populateResultSet()
    {
            /*Run query and populate resultSet - either as sql result or parse to array - your call*/
    }
    /**
     *
     * @var PDO $conn 
     */
    private $conn;

    public function __construct()
    {
                /*Get sql connection if one hasn't already been established*/
                if(!CategoriaDAO::dbConnection)
                        $this->conn = PDOConnectionFactory::getConnection();
    }
}

Myšlenkový proces za tím spočívá v tom, že vzhledem k tomu, že výsledky budou vždy stejné (prozatím ignorovat, aktualizovat, vkládat, mazat), není potřeba uchovávat kopii výsledků v každém objektu.

Jak jste zdůraznili, aktualizace tabulky vyřadí uloženou sadu výsledků ze synchronizace s objektem; zde bych se rád trochu vrátil a řekl, že pokud musí být výsledná sada pro daný objekt aktuální pouze v době vytvoření, použijte normální členy objektu.

Nezávisle i ve spojení s předchozím komentářem stojí za zvážení také to, zda se dotaz změní nebo ne a zda se změní, vyžaduje vygenerování členů objektu. Pokud se dotaz nezmění, není se čeho obávat – kromě předchozího bodu. Pokud se to změní, vaše možnosti jsou víceméně popsány v následujících příkladech.

class Foo{
    private $someMember;

    /*
        $params = Associative array of fields and values
    */
    private static buildAndRunQuery($params)
    {
        /*Build sql query based on the given params Array()*/
    }
    public __construct($someMemebrValue)
    {
        $this->someMember = $someMemberValue;
        Foo::buildAndRunQuery(Array("fieldName" => $this->someMember));
    }
}

V tomto příkladu stále používáte statickou metodu pro generování dotazu, ale předáváte nestatické členy procesu/ V tomto okamžiku (viz komentář k objektům, které jsou aktuální v době vytvoření) můžete buď uložit výsledky v rámci statického člena nebo je předejte zpět funkci __construct() a uložte je do instance objektu.

Pak je tu možnost, že dotaz, který používáte, je o něco složitější než pouhé vyžadování určitých polí, takže vytvoření vícerozměrného pole pro předání statické funkci by bylo více potíží, než by stálo za to. V takovém případě byste mohli rozdělit buildAndRunQuery() na buildQuery() – metodu instance a runQuery() statickou metodu, jako je např.

class Foo{

    private $someMember;

    /*
        $params = Associative array of fields and values
    */
    private static runQuery($query)
    {
        /*Build sql query based on the given params Array()*/
    }

    private function buildQuery()
    {
        /*Construct your query here and either return calling method or store in instance member*/
         /*Either*/
            return <Constructed query>;
        /*Or*/
           $this->query = <Constructed query>;
    }

    public __construct($someMemebrValue)
    {
        $this->someMember = $someMemberValue;
        /*As per buildQuery() comment either:*/
            Foo::runQuery($this->buildQuery());
        /*Or*/
            Foo::runQuery($this->query);
    }
}

V tomto případě existuje několik možností pro zpracování vygenerovaného dotazu před voláním Foo::runQuery().

Samozřejmě vždy existuje možnost, že nechcete vytvářet a spouštět dotaz synchronním způsobem nebo dokonce v konstruktoru.

Na závěr se osobně domnívám, že pro metody, které interagují se službami nezávislými na objektu samotném, jako je Sql nebo možná zaměřený DOMDocument nebo podobné interakce s objekty, je nejlepší použít statické metody tam, kde jsou obě relevantní a neuříznou vám nos. navzdory svému obličeji (zbytečně složitému atd.). To vše je samozřejmě potřeba zvážit na základě třídy.