Patróns de deseño PHP
Visión global: Todos sabemos o quão importante os patróns de deseño tornar-se unha parte esencial no desenvolvemento de aplicacións de hoxe, sexa ela de calquera tecnoloxía. Na tecnoloxía PHP tamén patrón de deseño tornar-se parte integrante do desenvolvemento. Commonly used design patterns are also followed in the PHP development world.
Neste artigo vou falar sobre os distintos patróns de deseño que se utilizan no ámbito PHP con algunhas aplicacións de exemplo.
Introdución: patróns de deseño fornecen unha solución reutilizable xenérico para problemas comúns. Deseño proba non é unha solución de formigón que se pode converter en código fonte ou un código de máquina pola contra, é un modelo que se pode empregar para resolver un problema en situacións diferentes. Os patróns de deseño axudar no desenvolvemento máis rápido que os modelos son comprobadas e do punto de colaborador, só é necesaria a implantación. patróns de deseño non só facer o desenvolvemento de software máis rápido, pero tamén encapsulado grandes ideas dun xeito máis sinxelo. No mundo de PHP, tras cinco patróns de deseño son usados en xeral -
- O defecto de fábrica
- O patrón Singleton
- O patrón Observer
- A Cadea de patrón de mando
- O nivel de estratexia
O defecto de fábrica:
O defecto de fábrica ofrece unha solución que permite o acoplamento feble, así, nos axuda a se librar do problema de acoplamento forte. Como un creador de todos están ben conscientes dos cambios afrontadas mentres mantemos un código, que está intimamente ligado. defecto de fábrica ofrece unha clase que ten algúns métodos para crear obxectos para nós en tempo de execución. No canto de crear a instancia directamente usan a fábrica para crear os obxectos para nós. Thus, si temos que cambiar o tipo de obxecto creado, só necesitamos cambiar a fábrica. O código a continuación é un exemplo de implementación de fábrica en PHP -
Listing 1: Unha implementación de fábrica de exemplo en PHP
[Code]
<?php
interface co cliente
{
getName función();
}
clase Cliente aplica Cliente
{
__construct función pública ( $identidade ) { }
getName función pública ()
{
return “PHP - defecto de fábrica”;
}
}
CustomerFactory clase
{
public static function Crear ( $identidade )
{
volver novo cliente ( $identidade );
}
}
$uo = CustomerFactory::crear ( 1 );
eco ( $uo->getName().”\n” );
?>
[/Code]
No exemplo anterior, temos unha interfaz chamada, Cliente, que ten a definición do obxecto. Esta interface é aplicado na clase Cliente. O CustomerFactory clase de fábrica crea os obxectos Customer. Se executar este código na liña de comandos que ten un intérprete PHP obtemos o resultado como -
[Code]
% php factorySample.php
PHP - defecto de fábrica
%
[/Code]
O patrón Singleton:
Como o nome suxire, patrón Singleton permite só unha instancia a ser creada. Ao desenvolver unha aplicación, nos atopamos con moitas situacións nas que necesitamos ter só unha instancia dun obxecto. Este exemplo pode ser compartido por procesos diferentes. E.g. unha obxectos de conexión de base de datos. É sempre recomendable para crear e destruír o obxecto de conexión de base de datos, a fin de evitar a sobrecarga de abrir e pechar a conexión. O código a seguir mostra como aplicar Singleton en PHP -
Listing 2: implantación Singleton en PHP
[Code]
<?php
require_once(“DB.php”);
DatabaseConnection clase
{
getDBO public static function ()
{
estática $ db = null;
se ( $db == null )
$db = new DatabaseConnection();
return $ db;
}
private $ _handle = null;
__construct función privada()
{
$DSN = 'MySQL://raíz:password@dbhost/dbinstance’;
$this->_handle =& DB::Conectar( $DSN, orde() );
}
Handle función pública()
{
return $ this->_handle;
}
}
impresión( “Handle = “.DatabaseConnection::obter()->manexar().”\n” );
impresión( “Handle = “.DatabaseConnection::obter()->manexar().”\n” );
?>
[/Code]
O código anterior mostra como conseguir a conexión db usando o achegamento Singleton. O constructor privado nesta clase garante que non pode ser chamado de fóra da clase. O método estático - getDBO () é chamada desde a clase chamada para obter o obxecto de conexión DB.
O patrón Observer:
O observador estándar é moi á fronte. Un obxecto faise observable a través da adición de un método que permite que un outro obxecto, o observador a obter rexistrado. Se o obxecto observable modifícase, el envía unha mensaxe para os obxectos que están rexistrados como observadores. O código a seguir mostra como aplicar o patrón Observer -
Listing 3: implementación estándar Observer en PHP
[Code]
<?php
Observer Interface
{
función onChanged( $remitente, $args );
}
interface observable
{
addObserver función( $observador );
}
clase CustomerList aplica observable
{
$ _observers Privadas = array();
addCustomer función pública( $nome )
{
para cada un( $this->_observers como $ obs )
$obs->onChanged( $esta, $nome );
}
addObserver función pública( $observador )
{
$this->_observers []= $ Observador;
}
}
clase CustomerListLogger aplica Observer
{
función pública onChanged( $remitente, $args )
{
eco( “'$ Args’ Cliente foi engadido á lista n” );
}
}
$ul = new UserList();
$sobrepasar>addObserver( nova CustomerListLogger() );
$sobrepasar>addCustomer( “toma” );
?>
[/Code]
O código anterior define dúas interfaces e as súas respectivas clases de implantación.
A cadea de patrón de mando:
A cadea de patrón de mando é outro estándar que está baseado no concepto de acoplamento. Aquí, cada adestrador decidir se pode xestionar a petición ou non. se poida, a petición é tratado eo proceso é detido. Se non, a petición é, entón, pasado á seguinte rutina de tratamento etc.. O código a continuación é un exemplo de implementación deste estándar -
Listing 4: Exemplo de código de execución Cadea de patrón de comandos -
[Code]
<?php
Command Interface
{
función baixo pedido( $nome, $args );
}
clase CommandChain
{
$ _commands Privadas = array();
addCommand función pública( $cmd )
{
$this->_commands []= $ Cmd;
}
RunCommand función pública( $nome, $args )
{
para cada un( $this->_commands como $ cmd )
{
se ( $cmd->Oncommand( $nome, $args ) )
return;
}
}
}
clase CustCommand aplica Command
{
función pública baixo pedido( $nome, $args )
{
se ( $nome != 'AddCustomer’ ) return false;
eco( “Esta é a manipulación CustomerCommand n 'addCustomer'” );
return true;
}
}
clase MailCommand aplica Command
{
función pública baixo pedido( $nome, $args )
{
se ( $nome != 'Correo’ ) return false;
eco( “Este é MailCommand manipulación 'mail' n” );
return true;
}
}
$cc = new CommandChain();
$CC->addCommand( nova CustCommand() );
$CC->addCommand( nova MailCommand() );
$CC->RunCommand( 'AddCustomer', cero );
$CC->RunCommand( 'Mail', cero );
?>
[/Code]
O nivel de estratexia:
O nivel de estratexia baseado en algoritmos. Os algoritmos complexos son extraídos a partir das clases de xeito que poden ser facilmente substituídos. patrón de estratexia baseado na teoría de plug and play. Unha implementación común do patrón de estratexia é se queremos cambiar a forma en que as páxinas son clasificados na páxina de resultados de busca. A posta en marcha de exemplo móstrase a continuación -
Listing 5: implementación de exemplo do estándar Strategy
[Code]
<?php
Estratexia de interface
{
filtro de función( $rexistro );
}
clase FindAfter aplica Estratexia
{
$ _name Privada;
__construct función pública( $nome )
{
$this->_name = $ name;
}
Filtro función pública( $rexistro )
{
strcmp retorno( $this->_name, $rexistro ) <= 0;
}
}
clase FindRandom aplica Estratexia
{
Filtro función pública( $rexistro )
{
rand retorno( 0, 1 ) >= 0.5;
}
}
clase CustomerList
{
Private $ _list = array();
__construct función pública( $nomes )
{
se ( $nomes != null )
{
para cada un( $nomes como $ name )
{
$this->_list []= Name $;
}
}
}
public function add( $nome )
{
$this->_list []= Name $;
}
find función pública( $filtro )
{
$Recs = array();
para cada un( $this->_list como $ user )
{
se ( $filter->filtro( $user ) )
$Recs []= Usuario $;
}
voltar $ Recs;
}
}
$ul = new CustomerList( orde( “e Joe”, “Ric Anderson”, “Nick Paul”, “Megan Pit” ) );
$f1 = $ sobrepasar>atopar( nova FindAfter( “J” ) );
print_r( $f1 );
$f2 = $ sobrepasar>atopar( New FindRandom());
print_r( $f2 );
?>
[/Code]
Here, a clase CustomerList é un invólucro que ten unha matriz de algúns nomes. Esta clase aplica un método de procura que leva unha das varias estratexias para a selección de un subconxunto destes nomes. As estratexias son definidas pola interface Estratexia, que ten dúas implementacións: O primeiro escolle os clientes aleatoriamente mentres que o outro escolle todos os nomes tras un nome especificado.
Summary: Así, patróns de deseño son algunhas das grandes ideas que se poden usar en calquera linguaxe de programación, incluíndo PHP. Nós discutir os patróns de deseño máis comúns usados en aplicacións PHP.
Imos completar a nosa discusión cos seguintes balas -
- Os patróns de deseño son usados en todas as tecnoloxías para axudar desenvolvedores a seguir unha visión solución reutilizable común para problemas comúns.
- Deseño Patterns non son concretos, pero son conceptuais.
- Como outras linguaxes, PHP tamén usa os patróns de deseño comúns, algúns dos cales están explicados anteriormente.
