Definição do padrão de fábrica: fornece uma interface para criar objetos.
Por que usar o modo de fábrica
O modelo de fábrica é o modelo mais usado que usamos.
Por que o modelo de fábrica é tão comumente usado? Como o padrão de fábrica é equivalente à criação de novos objetos de instância, geralmente precisamos gerar objetos de instância com base na classe. Precisa ter mais cuidado.
Vamos pegar a classe de amostra como exemplo.
A cópia do código é a seguinte:
Amostra de amostra = nova amostra ();
No entanto, a realidade é que geralmente fazemos algum trabalho de inicialização ao criar instâncias de amostra, como bancos de dados de consultas de atribuição, etc.
Primeiro de tudo, o que pensamos é que podemos usar o construtor da amostra, para que a instância seja gerada e escrita como:
A cópia do código é a seguinte:
Amostra de amostra = nova amostra (parâmetro);
No entanto, se o trabalho de inicialização realizado ao criar uma instância de amostra não for tão simples quanto a atribuição, pode ser uma peça longa de código.
Por que o código é feio? O método é equivalente a colocar muitos ovos nele. Despacho de código longo em cada segmento e o segmento é "encapsulado" novamente (reduzindo a conexão de acoplamento entre segmentos), para que os riscos sejam diversificados. Não há mais coisas que afetarão cada segmento.
Neste exemplo, primeiro, precisamos separar o trabalho de criar uma instância do trabalho de usar uma instância, ou seja, separar a grande quantidade de trabalho de inicialização necessário para criar uma instância do construtor da amostra.
No momento, precisamos do padrão de fábrica da fábrica para gerar objetos e não podemos mais usar a nova amostra simples (parâmetros). Além disso, se a amostra tiver uma herança como o MySample, de acordo com a programação orientada para a interface, precisamos abstrair a amostra em uma interface. Agora, a amostra é uma interface, com duas subclasses MySample e Siissample. Quando queremos instanciá -los, como segue:
A cópia do código é a seguinte:
Amostra mySample = new MySample ();
À medida que o projeto se aprofunda, a amostra pode "trazer muitos filhos", então precisamos instanciar esses filhos um por um é inevitável em programas tradicionais.
Mas se você conscientemente usar o modelo de fábrica desde o início, esses problemas desapareceram.
Método da fábrica
Você construirá uma fábrica especializada na produção de instâncias de amostra:
A cópia do código é a seguinte:
Public Class Factory {
Criador de amostra estática pública (int que) {
// GetClass Gere a amostra Geralmente, o carregamento dinâmico de classe pode ser usado para carregar classes.
if (que == 1)
devolver novas amostras ();
caso contrário, se (que == 2)
return new sampleb ();
}
}
Então, em seu programa, se você deseja instanciar a amostra, use o código de cópia da seguinte forma:
Amostra de amostra = fábrica.creator (1);
Dessa forma, a subclasse específica da amostra não está envolvida em todo o processo. Quanto mais fácil é cometer erros. Todo mundo que fez um trabalho específico tem um profundo entendimento disso. Parece que também podemos entender os princípios da vida da programação?
Use métodos de fábrica para prestar atenção em várias funções. Para gerar a amostra do produto, como mostrado na figura abaixo.
Para ser mais complicado, é expandir a classe de fábrica, que também herda sua classe de implementação concreta.
Fábrica abstrata
O modelo de fábrica inclui: método de fábrica e fábrica abstrata.
A diferença entre esses dois padrões está na complexidade da criação de objetos. Se nosso método de criar um objeto se tornar complicado, como no método de fábrica acima, é criar uma amostra de objeto, se tivermos uma nova amostra de interface de produto2.
Assumindo aqui: a amostra possui duas classes de concreto amostras e samleb, e o Sample2 também possui duas classes de concreto Sample2a e Sampleb2. Diferentes partes da implementação da subclasse, o seguinte é expandir a fábrica no exemplo acima em uma fábrica abstrata:
A cópia do código é a seguinte:
Public Abstract Class Factory {
Criador de amostra abstrata pública ();
Public Abstract Sample2 Creator (Nome da String);
}
classe pública SimpleFactory estende a fábrica {
Public Sample Creator () {......... Retornar novas amostras}
public Sample2 Creator (Nome da String) {......... Retornar Novo Sample2a}
}
classe pública bombfactory estende a fábrica {
Public Sample Creator () {...... Retornar novo SampleB}
public Sample2 Creator (Nome da String) {...... Retornar Novo Sample2b}
}
A partir do exposto, as duas fábricas produzem um conjunto de amostra e amostra2.
Há outro ponto -chave na fábrica abstrata, porque existe uma certa conexão entre os métodos que produzem amostra e amostra 2 em Factory, portanto, esses dois métodos precisam ser agrupados em uma classe O processo é unificado, por exemplo: o processo de fabricação é relativamente simples, portanto o nome é simples.
Em aplicações práticas, o método da fábrica é usado com mais frequência e é combinado com carregadores de classe dinâmicos.
Exemplos de Java Factory Model
Vamos tomar o FORUMFACTIONAL DE JIVE como exemplo.
A cópia do código é a seguinte:
Public Abstract Class ForumFactory {
Objeto estático privado initlock = novo objeto ();
Public Static ForumFactory GetInstance (autorização da autorização) {
// Se nenhuma autorização válida foi aprovada, retorne nulo.
if (autorização == null) {return null;
// o seguinte usa o modo singleton singleton
if (fábrica == null) {
sincronizado (initlock) {
if (fábrica == null) {......
tentar {
// reimpressão dinâmica
Classe C = classe.ForName (ClassName);
fábrica = (ForumFactory) C.NewInstance ();
} catch (Exceção e) {return null;
}
}
}
// Agora, retorne proxy.
Retornar Novo ForumFactoryProxy (Autorização, Factory, Factory.GetPermissions (Autorização));
}
// O método de criação do fórum é concluído por uma subclasse herdadora de fórumes.
Public Resumo Forum CreateForum (nome da string, descrição da string)
lança UNAuthorizedException, forumalreadyexistsexception;
....
}
Como o Jive Now armazena postagens no fórum e outros dados de conteúdo através do sistema de banco de dados, se você deseja alterá -lo para ser implementado através do sistema de arquivos, esse fórum de métodos de fábrica fornece uma interface dinâmica:
A cópia do código é a seguinte:
String estática privada ClassName = "com.jiveSoftware.forum.database.dbforumFactory";
Você pode usar o método desenvolvido para criar fórum em vez de com.jiveSoftware.forum.database.dbforumFactory.
No código acima, existem três modos. Fórum de acesso: um se você é um usuário registrado e um convidado, as permissões correspondentes serão diferentes e essa permissão é executada por todo o sistema.
Confira o Catalogdaofactory na Java Pet Store:
A cópia do código é a seguinte:
classe pública Catalogdaofactory {
/**
* Este método desenvolve uma subclasse especial para implementar o padrão DAO.
* A definição específica da subclasse está no descritor de implantação J2EE.
*/
Public Static Catalogdao getdao () lança catalogdaosysexception {
Catalogdao catdao = nulo;
tentar {
InicialContext IC = new InitialContext ();
// carregamento dinâmico de catalog_dao_class
// você pode definir seu próprio catalog_dao_class, para que você não precise alterar muito código
//, complete as enormes mudanças do sistema.
String className = (String) IC.Lookup (jndinames.catalog_dao_class);
catdao = (Catalogdao) classe.ForName (ClassName) .NewInstance ();
} catch (namingException ne) {
lançar novo catalogdaosysexception ("catalogdaofactory.getdao: namingException enquanto obtém o tipo Dao: /n" + ne.getMessage ());
} catch (Exceção SE) {
lançar novo catalogdaosysexception ("catalogdaofactory.getdao: exceção ao obter DAO tipo: /n" + se.getMessage ());
}
retornar catdao;
}
}
O Catalogdaofactory é um método de fábrica típico. Implementar subclasses e fornecer seu próprio nome de subclasse para a variável catalog_dao_class.
Pode -se observar que o método da fábrica fornece um mecanismo de expansão dinâmica muito flexível e poderoso para a estrutura do sistema. é possível alterar as funções do sistema em uma transformação.