Ser redundante con Singleton, conceptos

[Covids0020]

Hola y antes de nada advierto que llevo muy poco de lleno en POO, como posiblemente se note en adelante ^^, así que sentiré si le doy alguna patada a los conceptos POO.

El tema es una cuestión de diseño, de concepto y se podría reducir a dos cosas:

1. ¿Es correcto usar getters, además privados (internos), para acceder a atributos también privados e internos, o simplemente se debe referenciar al atributo a pelo y yastá?

2. Sobre un Singleton que estoy usando, adaptado del gran Zsamer que andará por aquí:
Estoy trabajando con Zend Framework y esto ya me trae de cabeza. Pongo el código:

Código PHP:

// Modelos de datos:
private function _getModel($model)      { 
    if ( !empty($model) && method_exists('Core', 'getSingleton') ) 
        return (object) Core::getSingleton("{$model}");
    else 
        throw new Exception('No pudimos inicializar el modelo de datos.');
}
private function _getChokepointModel()  { return $this->_getModel('be/chokepoint'); }
private function _getFacilityModel()    { return $this->_getModel('be/facility'); }
private function _getUnitModel()        { return $this->_getModel('be/unit'); }
 

Al margen de lo que el código haga o deje de hacer, que creo no importa...
¿debería llamar al Singleton y punto?
Es que, aunque me parece funcional para comprobar un error que aunque no debería podría ocurrir, y abstraer al resto de métodos de la forma en que obtengo el modelo de datos, me parece demasiado redundante... :(

3. No digo ya nada cuando me pasan cosas como esta que sigue, para intentar comprobar si tenemos el Singleton, la cuestión es que la comprobación, ese gasto, ese consumo, me lleva a intentar ya de paso instanciarlo... y como es lógico, pues el Sigleton pierde todo su sentido. Es decir:

Código PHP:

public function __construct() {
    // Core Singleton:
    if ( method_exists('Core', 'getsingleton') ) {
        if ( null ===  $this->_model )
            $this->_model           = $this->_getCore()->getSingleton('default/xmlresources');
    } else 
        throw new Exception('No obtuvimos un gestor del modelo de datos.');
}
/* Este método es bastante tonto la verdad xDD */
private function _getCore() {
    if ( !@class_exists('Core') )
        throw new Exception('No tenemos la clase Core.');
    else
        return (object) new Core();
}
private function _getCPFile($citys = true) {
    $fileCitys = ( isset($citys) && false !== $citys ) ? '.citys' : '';
    $fileCPs = $this->_model->getResource("cplist{$fileCitys}");
    return (string) $fileCPs;
}
 

Toma ya xDDD
Sé que _getCore(), así tal como está la cosa es bastante inútil ya que la clase -el Singleton- se comprueba en el constructor... pero podría ser que no, o no usarse ese constructor y que el siguiente miembro usará directamente _getCore() para obtener el Singleton.
En cualquier caso sé que es aberrante... pero cuando se usan Singleton, cualquier intento de comprobarlo o abstraer a otros métodos frente éste, siempre que no se le llame directamente va a ser poco lógico, ¿no?

Bueno... es obvio que me lío un poco, como siempre, muchas gracias de antemano, en especial a los gurús: Enriqueplace y gator ;)
Un saludo.

PD - Off Topic: Si alguien conoce el 2online estoy trabajando en ello, con Wiretap ;)

[GatorV]

1.- Es el concepto de encapculación, siempre usa getters/setters para leer las variables y no uses variables públicas.

2.- Mejor usa el Singleton directamente, ya que sí lo programas así no debería de fallar nunca...

Saludos.

[Covids0020]

Gracias Gator ;)
1. Pues tenía claro esas lapidarias reglas pero... debería haber puesto el código porque me seguía pareciendo redundante. El problema vuelvo a ser yo y no estar acostumbrado a la POO imagino.
2. Comentándolo con un colega llegué a la misma conclusión: es un error de diseño.
Se supone que si diseñas un Singleton es para usarlo de acuerdo a su concepto, claro.

La cuestión que me parece ver es que, en ocasiones, las dos cosas pueden parecer contradictorias: Singleton frente encapsulación, pero de nuevo imagino que depende de como armes tu sistema :S

[GatorV]

1.- No son lapidarias reglas, simplemente es la forma correcta de diseñar una clase, tu eres libre de hacerlo accediendo a las variables publicas, pero eso luego te trae mas dolores de cabeza que soluciones.

No va nada en contra, Singleton es un patrón de diseño para tener solo una instancia de tu clase, y sepas que esa instancia es la única usada (util por ejemplo para conexiones a BDD), y Encapsulación es eso, que tu objeto este lo mas aislado posible y no sea afectado por nada a menos que tu desees que sea afectado y puedas controlar bajo que contexto es afectado.

Saludos.

[Covids0020]

Lo único que yo pienso es por ejemplo esto:
Por esa regla, podría usar un Singleton en ese objeto y al cabo del tiempo modificar ese Singleton, por ejemplo su nombre (solo es a modo de ejemplo); el objeto se caería.
Es, según yo lo veo, una modificación externa, pero a la vez, para evitar esto, es ilógico también instanciar el Singleton dentro de tu objeto para tener una sola referencia -dentro de tu objeto me refiero- y mejorar posibles errores.

Supongo que es el punto de vista. En mi caso particular creo que no debería haberlo usado y por eso lo veo de esta manera, lo cual cambia bastante en un Singleton tan genérico y habitual como el que comentas de la base de datos.

Por ejemplo, hay casos (1er código que puse) en los que me es perfectamente válido pues solo uso un método para obtener otro, u otros, métodos del Singleton y que el resto de miembros lo usen. O sea, si se me cae, sé dónde exactamente lo llamé.
Si por el contrario hay más miembros que directamente usan los métodos del Singleton... hay que repasarlos todos. Solo es esta mi tribulación.

Pero vamos... como decía, imagino que solo se trata del diseño de la aplicación. No estoy afirmando nada -por ejemplo eso de que vaya en contra-, solo son impresiones que sé que tengo algo confundidas o poco claras y por eso las ilustro;
y de hecho agradezco las ayudas :)

Un saludo ;)

PD: Para ciertas cosas soy bastante dogmático e incluso talibán ggg, de ahí que las entienda -al menos personalmente- como lapidarias xD

[GatorV]

Pues si cambias el nombre del objeto, por eso es recomendable dentro del objeto usar self, para referirte al objeto, ahora si vas a estar cambiando de nombres de objetos te recomiendo re-pienses tu diseño ya que no es lo mas correcto.

Por otro lado como te comentaba no estas obligado a seguir un patrón de diseño, estos estan para ayudarte y hacer tu código más extensible, y mantenible, pero siempre puedes hacerlo de la forma que mejor te sientas, solo toma el mensaje anterior que te habia dejado, luego la tarea de darle mantenimiento va a ser muy complicada.

Saludos.

[Covids0020]

Okis, gracias :)
Sé que no tiene mucha más «chicha» el asunto pero es que soy muy malo explicándome y concretando xP.
Además había perdido el foco sobre tus primeras respuestas:

2.- Mejor usa el Singleton directamente, ya que sí lo programas así no debería de fallar nunca...

A ver si así cierro el tema, no quiero ser pesado, Gator ;)
Sobre todo me gustaría conocer cual creéis que es la forma más correcta de hacer lo siguiente, en vuestra opinión, en vuestra forma de trabajo, aunque puedan ser válidas ambas:

O sea, supongo que frente a esto:

Código PHP:

// Singleton para modelos de datos:
private function _getModel($model)      { 
    if ( !empty($model) && method_exists('Core', 'getSingleton') ) 
        return (object) Core::getSingleton("{$model}");
    else 
        throw new Exception('No pudimos inicializar el modelo de datos.');
}
private function _getChokepointModel()  { return $this->_getModel('be/chokepoint'); }
private function _getFacilityModel()    { return $this->_getModel('be/facility'); }
private function _getUnitModel()        { return $this->_getModel('be/unit'); }
 

Simplemente debería hacer esto:

Código PHP:

// Modelos de datos:
private function _getChokepointModel()  { return Core::getSingleton('be/chokepoint'); }
private function _getFacilityModel()    { return Core::getSingleton('be/facility'); }
private function _getUnitModel()        { return Core::getSingleton('be/unit'); }
 

C'est fini y gracias por todo ;)

PD: Sobre el cambio de nombre me refería a la clase del Singleton, pero sí, está claro que es un fallo de diseño. Algo que considero normal ahora que estoy empezando pues no tengo una metodología establecida aún, además de muchos conceptos como es obvio :D

[GatorV]

Pues la idea de Singleton es tener una clase de todo, por lo que veo tu lo que necesitas es el patrón Factory para cargar tus modelos de datos.

Saludos.

[Covids0020]

Joder, pues es lo que también me comentó el otro colega y lo que yo -sin saberlo- ya tenía hecho antes :( ...solo que algo chapucero.
Bien... pues de nuevo gracias por tu tiempo, en serio que se agradece el interés que presta gente como tú ;)

PD: Es que llevo semanas dándole vueltas a algún buen libro sobre patrones de diseño