O escopo de aplicação do modo construtor: você deseja criar um objeto composto de várias partes, e sua composição deve ser concluída passo a passo. Este objeto está completo apenas quando todas as partes são concluídas. O modo construtor representa a separação da criação e performance de objetos complexos, de forma que o mesmo processo tenha performances diferentes.
Assumindo que queremos criar um gerador de página HTML, podemos usar o modo builder. Nesta modalidade, existem dois participantes: o construtor e o diretor. O construtor é responsável por criar os vários componentes do objeto. No exemplo de HTML, esses componentes incluem: título da página, título do texto, corpo do conteúdo e rodapé. O líder usa uma instância do construtor para controlar o processo de construção. Para exemplos de HTML, refere-se a chamar a função do construtor para definir o título da página, título do texto, etc. O uso de diferentes instâncias do construtor nos permite criar diferentes páginas HTML sem alterar o código do comandante.
1. Exemplos na vida real
O restaurante de fast food usa o padrão de design do construtor. Mesmo que existam vários hambúrgueres (clássico, cheeseburger, etc.) e embalagens diferentes (caixas grandes, médias, pequenas, etc.), o processo de preparação do hambúrguer e da embalagem (caixa ou saco de papel) é o mesmo. A diferença entre os dois hambúrgueres está no desempenho, não no processo de construção. O comandante é o caixa, que comunica as instruções sobre que comida preparar para a equipe, o construtor.
2. Exemplos de software
O exemplo HTML mencionado no início deste artigo foi praticamente aplicado no django-widgy. django-widgy é uma extensão de editor de árvore de terceiros para Django que pode ser usada como um sistema de gerenciamento de conteúdo. Ele contém um construtor de páginas da web para criar páginas HTML com diferentes layouts.
django-query-builder é outra biblioteca de extensão de terceiros do Django baseada no modo builder, que pode ser usada para construir consultas SQL dinamicamente. Usando-o, podemos controlar todos os aspectos de uma consulta e criar diferentes tipos de consultas.
3. Caso de aplicação
Se sabemos que um objeto deve passar por várias etapas para criar e exigir que o mesmo processo de construção possa ser usado para produzir um desempenho diferente, podemos usar o modo construtor. Por exemplo, geradores de páginas, conversores de documentos, interfaces de usuário, etc.
A diferença entre o modo de fábrica e o modo de construtor é que o modo de fábrica cria objetos em uma única etapa, enquanto o modo de construtor cria objetos em várias etapas e quase sempre usa um líder. Algumas implementações de padrão de construtor direcionadas não usam comandantes, como StringBuffer do Java.
Outra diferença é que no modo de fábrica, um objeto criado é retornado imediatamente; no modo de construtor, o código do cliente apenas solicita explicitamente ao comandante para retornar o objeto final quando necessário.
O exemplo da nova analogia do computador pode ajudar a distinguir o modelo do construtor do modelo da fábrica. Suponha que você queira comprar um novo computador.Se você decidir comprar um modelo de computador pré-configurado específico, por exemplo, o mais recente Mac mini de 1,4 GHz da Apple, você usa o modelo de fábrica. As especificações de todos os hardwares são pré-determinadas pelo fabricante, e o fabricante sabe o que fazer sem consultar você, geralmente recebe apenas uma instrução. código mostrado abaixo
MINI14 = 'Mac mini de 1,4 GHz'
classe AppleFactory:
classe MacMini14:
def __init __ (self):
self.memory = 4 # Unidade é GB
self.hdd = 500 # Unidade é GB
self.gpu = 'Intel HD Graphics 5000'
def __str __ (self):
info = ('Model: {}'. format (MINI14), 'Memory: {} GB'.format (self.memory),' Hard Disk: {} GB'.format (self.hdd), 'Placa gráfica: {} '. formato (self.gpu))
retornar '\ n'.join (informações)
def build_computer (self, model):
if (modelo == MINI14):
return self.MacMini14 ()
outro:
print ("Não sei como construir {}". format (model))
if __name__ == '__main__':
afac = AppleFactory ()
mac_mini = afac.build_computer (MINI14)
imprimir (mac_mini)
Outra opção é comprar um PC personalizado. Nesse caso, o modo construtor é usado. Você é o comandante, fornecendo instruções ao fabricante (construtor) para explicar as especificações ideais do computador em sua mente.
classe Computer:
def __init __ (self, serial_number):
self.serial = serial_number
self.memory = Nenhum # Unidade é GB
self.hdd = Nenhum # Unidade é GB
self.gpu = Nenhum
def __str __ (self):
info = ('Memória: {} GB'.format (self.memory),' Disco rígido: {} GB'.format (self.hdd), 'Placa de vídeo: {}'. format (self.gpu))
retornar '\ n'.join (informações)
classe ComputerBuilder:
def __init __ (self):
self.computer = Computador ('AG23385193')
def configure_memory (self, amount):
self.computer.memory = quantidade
def configure_hdd (self, amount):
self.computer.hdd = quantidade
def configure_gpu (self, gpu_model):
self.computer.gpu = gpu_model
classe HardwareEngineer:
def __init __ (self):
self.builder = Nenhum
def construct_computer (self, memory, hdd, gpu):
self.builder = ComputerBuilder () ①
[passo para passo em (self.builder.configure_memory (memory), self.builder.configure_hdd (hdd), self.builder.configure_gpu (gpu))]
@propriedade
def computador (próprio):
return self.builder.computer
def main ():
engenheiro = HardwareEngineer ()
engine.construct_computer (hdd = 500, memory = 8, gpu = 'GeForce GTX 650 Ti')
computer = engineer.computer
imprimir (computador)
if __name__ == '__main__':
a Principal()
A mudança básica é a introdução de um construtor ComputerBuilder, um comandante HardwareEngineer e o processo de montagem de um computador passo a passo, de modo que agora sejam suportadas diferentes configurações (observe que memória, disco rígido e gpu são parâmetros formais e não predefinidos) .
4. Resumo
Neste capítulo, aprendemos como usar o padrão de projeto do construtor. Você pode usar o padrão do construtor para criar objetos em alguns cenários onde o padrão de fábrica (método de fábrica ou fábrica abstrata) não é aplicável. Nas situações a seguir, o modo de construtor é uma escolha melhor do que o modo de fábrica.
[] Deseja criar um objeto complexo (o objeto é composto de várias partes e o processo de criação do objeto resulta em várias etapas, e talvez essas etapas precisem de uma ordem específica).
[] Exigir que um objeto tenha muitos desempenhos diferentes e espero que a estrutura e o desempenho do objeto tenham um baixo grau de acoplamento
[] Quer criar objetos em momentos diferentes
Vimos como os restaurantes de fast food usam o modo builder para preparação de comida e como os dois pacotes de extensão Django de terceiros (django-widgy e django-query-builder) usam o modo builder para gerar páginas HTML e consultas SQL dinâmicas. Nós nos concentramos em aprender a diferença entre o modo de construtor e o modo de fábrica e esclarecemos os dois modos de design comparando o computador pré-configurado (de fábrica) e o computador personalizado (construtor) com o pedido.
O texto acima é todo o conteúdo deste artigo, espero que seja útil para o estudo de todos e espero que você possa apoiá-lo.