Mantendo tudo fracamente acoplada e extensíveis: muitas camadas, muito pequeno ROI?
https://stackoverflow.com/questions/1251015
-
12-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
I (agora mais do que nunca) ver os desenvolvedores a escrever grandes quantidades de camadas, tais como:
implementation PresentationLayer ->
interface IMyDTO ->
implementation MyDTO ->
interface IMyService ->
implementation MyService ->
interface IMyDomainRepository ->
implementation MyDomainRepository ->
interface IMyDomainObject ->
implementation MyDomainObject ->
interface IMyIndependentStorageLayer ->
implementation MyMSSQLStorageLayer
Olhando através C blogs #, esta parece ser a melhor coisa desde o pão fatiado. Basicamente, tudo é baixo acoplamento. Não use um objeto de domínio diretamente. tudo executado através de uma camada de serviço. dados de acesso por meio de um repositório. Todas as camadas são perfeitamente independente.
Não me entenda errado, eu gosto da idéia, mas não é o trade-off no tempo enorme, especialmente em um projeto maior? É o ROI na manutenção realmente grande o suficiente para justificar isso?
As explicações que li são uma espécie de estranho, como "Dessa forma eu posso anexar um banco de dados diferente se eu precisar". Sério? Eu não acho que é um problema comum que alguém de repente exige a mudança de MSSQL para Oracle e agora você se sentar lá e gostaria de ter um milhão de camadas que todos não sabem uns dos outros.
Existe uma tendência em ir ao mar com baixo acoplamento, ou estou apenas lendo os blogs erradas? Como você se sente sobre isso, e você já teve casos em que você estava realmente feliz depois que você fez o trabalho extra no começo?
Solução
É muito difícil projetar o negócio alinhado concepção certo para um software. Quer dizer com um ROI aceitável.
No entanto, para mim, o número de camadas ou o nível de-baixo acoplamento de uma concepção de software é, dependendo do contexto em que o software será usado!
Se você tem certeza sobre o que o software tem a ver, e haverá provavelmente não grandes modificações ou acrescenta, no futuro, um baixo nível de super acoplamento aplicativo com um monte de camadas não é a solução. Porque torna a arquitetura muito complexa, sem qualquer motivo e o tempo investido para a arquitetura não é rentável ...
Por outro lado, se você sabe que a aplicação terá que ser personalizado para cada cliente e será certamente modificar em profundidade, assim que o tempo gasto para um nível baixo acoplamento arquitetura é uma boa idéia ...
acoplamento baixo nível pode ser inteligente quando você quer reutilizar parte do código para outra aplicação. Neste caso, tempo gasto para o projeto é totalmente rentável, é claro.
Então, em resumo, eu vou dizer que tudo depende da evolução do software no futuro e o potencial de reutilização de código para outras aplicações.
Mas é uma boa prática para me fazer não sistematicamente arquitetura muito complexa.
Outras dicas
Obviamente, ele pode ser exagerado, e é preciso saber "onde parar", acrescentando camadas.
Minha regra de ouro é que, se uma camada não precisa incluir qualquer funcionalidade / code significativa, eu não preciso disso. Dito isto, a capacidade de teste é uma coisa importante, por isso, se uma camada buys me melhor testabilidade, eu vou adicioná-lo.
Nada no aplicativo-design vem sem um preço. Aqui o preço é aumentado complexibility. Você sempre tem que olha através de suas opções antes de escolher aquele que se adapta melhor às suas necessidades.
Com isso dito, eu acho que sua pergunta soa um pouco tendencioso. No mundo real, você pode não ver muitas vezes um cliente exigindo um novo tipo de DB, mas você pode ver muitas vezes um novo cliente que quer o mesmo tipo de dados de acesso do que o anterior, mas em outro DB. Não é apenas sobre a facilidade de mudança, é também sobre code-reutilização.
Ao avaliar essas coisas eu costumo achar útil olhar para ele através da lente do princípio de DRY e olhando para a duplicação em seu projeto.
Se você estiver usando uma arquitetura que é mais complexo do que o seu projeto você tenderá a ver um monte de camadas que fazem pouco além de envolver outras camadas e passar em chamadas. Esta é repetir-se.
Se, por outro lado, você estiver usando uma arquitetura fina para um sistema complexo que você pode descobrir que a criação de funcionalidade em uma parte do sistema não permite que você reutilizar essa funcionalidade em outra parte, obrigando-o a escrever um monte de muito código semelhante em todo o lugar. Esta é repetir-se.
Na minha experiência, se você está vigilante na identificação de duplicação e constantemente refatoração para removê-lo, a estrutura irá se apresentar para você. Digamos, por exemplo, que você está começando com uma arquitectura bastante básico, mas quebrando as coisas em métodos logo que precisam ser reutilizados, e quebrar métodos para fora em classes, logo que eles precisam ser reutilizados por outras classes. Então você pode, eventualmente, perceber que seus 13 Helper / gerente aulas / manipulador que você escreveu para a duplicação remove realmente olhar um pouco como eles estão tomando a responsabilidade que poderia ter sido mais claramente definida se tivesse ido para uma camada de serviço.
Pode ser difícil saber quando vale a pena, mas acho que a chave para o sucesso na construção de um sistema com uma série de camadas está sendo muito claro com o que as responsabilidades das diferentes camadas deve ter. Qualquer camada que você adicionar deve ser útil para você na redução da complexidade das operações na camada acima dela e tornando mais fácil a funcionalidade tecer juntos em uma maneira elegante.
Vejamos um exemplo projeto hipotético. Os testes de utilizar várias bases de dados SQLite em processo para a velocidade, o banco de dados de desenvolvimento no computador de algum desenvolvedor é PostgreSQL, banco de dados intermediário é instalar um único Oracle, eo banco de dados de produção é um massivamente escalável, muito caro, e muito difícil de configurar o Oracle cluster.
Como você nunca iria fazer aquilo sem separar a camada de SQL a partir da camada de negócios?
É uma tendência recente, e leva menos experientes / arquitetos estão caindo presa de entrando na onda.
No projeto eu estou em, acesso a dados foi:
Interface Serviço -> Implementação Serviço -> Delegado Interface -> delegar a execução -> DAO Interface -> DAO Implementação -.> Ibatis XML
Este era (e é!) Mal no nosso caso, porque a maior parte do código em qualquer método de Implementação Delegado foi uma única linha; ele só chamou o DAO. Para cada DAO, tivemos duas aulas extras e uma configuração de feijão extra, e não estávamos ganhando nada com isso.
Aceite a mudança, refatorar, e seguir em frente. Use quantas camadas que leva a peça além conceitos diferentes ... e depois parar. Se não existe é percebido ganho de escrever algum código, exceto que ele vai seguir um modelo, quer abrandar e tentar compreender por que razão o modelo fez isso, ou aceitar que o modelo está errado para a sua aplicação e ignorar esse bocado.
Atualmente estou trabalhando em um projeto SOA grande, onde cada camada foi dissociado, e quase todas as classes é instanciado via alguma fábrica abstrato. Agora estamos tentando descarregar algumas das funcionalidades existentes em serviços hospedados separadamente, e é um verdadeiro pesadelo atravessando as camadas tentando extrapolar os bits importantes porque há um clique com o botão direito interminável> Ir para a definição ... a perseguição para baixo o que era apenas 1 linha de código na camada mais externa!
Não há nada de errado com dissociação per se, e, certamente, até mesmo no meu projeto há muitas áreas em que acho que é útil do ponto de vista arquitectónico. Só não se empolgue ... Ser pragmático, e pesar as vantagens / desvantagens quando se examina as áreas que você está considerando a possibilidade de dissociar.
Felicidades
