Configuração de XML versus configuração baseada em anotação [fechada]

Em alguns grandes projetos em que tenho trabalhado ultimamente, parece cada vez mais importante escolher um ou outro (XML ou Anotação). À medida que os projetos crescem, a consistência é muito importante para a manutenção.

Minhas perguntas são: quais são as vantagens da configuração baseada em XML sobre a configuração baseada em anotação e quais são as vantagens da configuração baseada em anotação sobre a configuração baseada em XML?

As anotações têm seu uso, mas elas não são a única bala de prata para matar a configuração XML. Eu recomendo misturar os dois!

Por exemplo, se estiver usando o Spring, é totalmente intuitivo usar XML para a parte de injeção de dependência do seu aplicativo. Isso afasta as dependências do código do código que o usará, pelo contrário, usando algum tipo de anotação no código que precisa das dependências, torna o código ciente dessa configuração automática.

No entanto, em vez de usar XML para gerenciamento transacional, marcar um método como transacional com uma anotação faz todo sentido, pois essas são as informações que um programador provavelmente gostaria de saber. Mas que uma interface será injetada como um SubtypeY em vez de um SubtypeX não deve ser incluída na classe, porque se agora você deseja injetar o SubtypeX, precisará alterar seu código, enquanto o contrato da interface era anterior, então com XML, você precisaria apenas alterar os mapeamentos XML, e é bastante rápido e fácil de fazer isso.

Como não usei anotações JPA, não sei se elas são boas, mas eu diria que deixar o mapeamento de beans no banco de dados em XML também é bom, pois o objeto não deve se importar de onde vieram as informações. , ele deve se preocupar apenas com o que pode fazer com suas informações. Mas se você gosta de JPA (eu não tenho nenhuma experiência com ele), por todos os meios, faça isso.

Em geral: se uma anotação fornecer funcionalidade e agir como um comentário por si só, e não vincular o código a algum processo específico para funcionar normalmente sem essa anotação, faça anotações. Por exemplo, um método transacional marcado como transacional não elimina sua lógica operacional e também serve como um bom comentário no nível do código. Caso contrário, essas informações provavelmente serão melhor expressas como XML, porque, embora acabem afetando o funcionamento do código, não alteram a funcionalidade principal do código e, portanto, não pertencem aos arquivos de origem.

Há um problema mais amplo aqui, o de meta-dados externalizados versus inline. Se o seu modelo de objeto persistir apenas de uma maneira, os metadados embutidos (por exemplo, anotações) serão mais compactos e legíveis.

Se, no entanto, seu modelo de objeto foi reutilizado em aplicativos diferentes, de maneira que cada aplicativo desejasse persistir o modelo de maneiras diferentes, a externalização dos metadados (ou seja, descritores XML) se tornaria mais apropriada.

Nenhum deles é melhor e, portanto, ambos são suportados, embora as anotações estejam mais na moda. Como resultado, novas estruturas de hair-to-fire como JPA tendem a colocar mais ênfase nelas. APIs mais maduras, como o Hibernate nativo, oferecem ambos, porque é sabido que nenhum deles é suficiente.

Eu sempre penso nas anotações como algum tipo de indicador do que uma classe é capaz ou de como ela interage com outras.

A configuração XML da Spring, por outro lado, é apenas isso, a configuração

Por exemplo, informações sobre o ip e a porta de um proxy estão definitivamente entrando em um arquivo XML, é a configuração do tempo de execução.

Usar @Autowire, @Elementpara indicar a estrutura, o que fazer com a classe é um bom uso de anotações.

Colocar o URL na @Webserviceanotação é um estilo ruim.

Mas esta é apenas a minha opinião. A linha entre interação e configuração nem sempre é clara.

Estou usando o Spring há alguns anos e a quantidade de XML necessária definitivamente estava ficando entediante. Entre os novos esquemas XML e o suporte a anotações no Spring 2.5, costumo fazer o seguinte:

1. Usando "component-scan" para carregar automaticamente classes que usam @Repository, @Service ou @Component. Normalmente, dou um nome a cada bean e os conecto usando @Resource. Acho que esse encanamento não muda com muita frequência, portanto as anotações fazem sentido.

2. Usando o espaço para nome "aop" para todos os AOP. Isso realmente funciona muito bem. Eu ainda o uso também para transações, porque colocar o @Transactional em todo o lugar é uma chatice. Você pode criar pointcuts nomeados para métodos em qualquer serviço ou repositório e aplicar rapidamente o conselho.

3. Eu uso LocalContainerEntityManagerFactoryBean junto com HibernateJpaVendorAdapter para configurar o Hibernate. Isso permite que o Hibernate descubra facilmente as classes @Entity automaticamente no caminho de classe. Em seguida, crio um bean SessionFactory nomeado usando "factory-bean" e "factory-method", referindo-se ao LCEMFB.

Uma parte importante do uso de uma abordagem somente de anotação é que o conceito de "nome do bean" desaparece mais ou menos (se torna insignificante).

Os "nomes de bean" no Spring formam um nível adicional de abstração sobre as classes de implementação. Com XML, os beans são definidos e referenciados em relação ao nome do bean. Com anotações, eles são referenciados por sua classe / interface. (Embora o nome do bean exista, você não precisa saber)

Acredito firmemente que se livrar de abstrações supérfluas simplifica os sistemas e melhora a produtividade. Para projetos grandes , acho que os ganhos com a eliminação do XML podem ser substanciais.

Eu acho que a visibilidade é uma grande vitória com uma abordagem baseada em XML. Acho que o XML não é tão ruim assim, dadas as várias ferramentas disponíveis para navegar em documentos XML (por exemplo, a janela Estrutura de arquivos do Visual Studio + ReSharper).

Você certamente pode adotar uma abordagem mista, mas isso me parece perigoso, apenas porque, potencialmente, dificultaria para os novos desenvolvedores de um projeto descobrir onde diferentes objetos são configurados ou mapeados.

Eu não sei; no final, o XML Hell não me parece tão ruim assim.

Depende do que tudo você deseja configurar, porque existem algumas opções que não podem ser configuradas com anotações. Se o virmos pelo lado das anotações:

• mais: as anotações são menos intensas
• menos: as anotações são menos visíveis

Cabe a você o que é mais importante ...

Em geral, eu recomendaria escolher uma maneira e usá-la em toda parte fechada do produto ...

(com algumas exceções: por exemplo, se você escolher configurações baseadas em XML, não há problema em usar a anotação @Autowire. É uma mistura, mas essa ajuda a facilitar a legibilidade e a manutenção)

Existem outros aspectos a serem comparados, como refatoração e outras alterações de código. ao usar XML, é necessário um grande esforço para refatorar, porque você precisa cuidar de todo o conteúdo XML. Mas é fácil ao usar anotações.

Minha maneira preferida é a configuração baseada em Java sem (ou mínimas) anotações. http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/beans.html#beans-java

Eu posso estar errado, mas pensei que as Anotações (como no @Tag de Java e no C # 's [Attribute]) eram uma opção em tempo de compilação, e XML era uma opção em tempo de execução. Isso para mim diz que não são equivalentes e têm diferentes prós e contras.

Eu também acho que uma mistura é a melhor coisa, mas também depende do tipo de parâmetros de configuração. Estou trabalhando em um projeto Seam que também usa o Spring e geralmente o implanto em diferentes servidores de desenvolvimento e teste. Então eu dividi:

• Configuração específica do servidor (como caminhos absolutos para recursos no servidor): arquivo Spring XML
• Injetando beans como membros de outros beans (ou reutilizando um valor definido em XML da Spring em muitos beans): Anotações

A principal diferença é que você não precisa recompilar o código para todas as configurações específicas do servidor, apenas edite o arquivo xml. Há também a vantagem de que algumas alterações na configuração podem ser feitas por membros da equipe que não entendem todo o código envolvido.

No escopo do contêiner de DI, considero que o DI baseado em anotação está abusando do uso da anotação Java. Ao dizer isso, não recomendo usá-lo amplamente em seu projeto. Se o seu projeto realmente precisa da capacidade do contêiner de DI, eu recomendaria usar o Spring IoC com a opção de configuração baseada em Xml.

Se for apenas para testar a Unidade, os desenvolvedores devem aplicar o padrão Dependency Inject em sua codificação e tirar proveito de ferramentas de simulação, como EasyMock ou JMock, para contornar dependências.

Você deve evitar o uso do contêiner de DI no contexto incorreto.

As informações de configuração que sempre serão vinculadas a um componente Java específico (classe, método ou campo) são um bom candidato a ser representado por anotações. As anotações funcionam especialmente bem nesse caso quando a configuração é essencial para a finalidade do código. Devido às limitações nas anotações, também é melhor quando cada componente pode ter apenas uma configuração. Se você precisar lidar com várias configurações, especialmente aquelas que são condicionadas a algo fora da classe Java que contém uma anotação, as anotações podem criar mais problemas do que resolvem. Finalmente, as anotações não podem ser modificadas sem recompilar o código-fonte Java; portanto, qualquer coisa que precise ser reconfigurável no tempo de execução não pode usar anotações.

Consulte os seguintes links. Eles podem ser úteis também.

1. Anotações vs XML, vantagens e desvantagens
2. http://www.ibm.com/developerworks/library/j-cwt08025/

Esta é a pergunta clássica 'Configuração versus Convenção'. O gosto pessoal determina a resposta na maioria dos casos. No entanto, pessoalmente, eu prefiro a Configuração (ou seja, com base em XML) sobre a Convenção. Os IDE da IMO são suficientemente robustos para superar algumas das pessoas infernais em XML que muitas vezes associam à construção e à manutenção de uma abordagem baseada em XML. No final, acho que os benefícios da Configuração (como criar utilitários para criar, manter e implantar o arquivo de configuração XML) superam a Convenção a longo prazo.

Eu uso os dois. Principalmente XML, mas quando tenho um monte de beans que herdam de uma classe comum e têm propriedades comuns, uso anotações para eles, na superclasse, para que não precise definir as mesmas propriedades para cada bean. Como sou um pouco maníaco por controle, uso @Resource (name = "referidosBean") em vez de apenas coisas de fiação automática (e economizo muitos problemas se precisar de outro bean da mesma classe que o referidoBean original) .

Existem alguns prós e contras da configuração da anotação da minha experiência:

• Quando se trata da configuração JPA, uma vez que é feita uma vez e geralmente não é alterada com frequência, prefiro manter a configuração da anotação. Talvez haja uma preocupação com a possibilidade de ver uma imagem maior da configuração - nesse caso, eu uso os diagramas do MSQLWorkbench.
• A configuração de XML é muito boa para obter uma imagem maior do aplicativo, mas talvez seja complicado encontrar alguns erros até o tempo de execução. Nesse caso, a anotação do Spring @Configuration soa como uma opção melhor, pois permite ver uma imagem maior e também permite validar a configuração em tempo de compilação.
• Quanto à configuração do Spring, prefiro combinar as duas abordagens: use a anotação @Configuration com interfaces Services e Query e a configuração xml para dataSource e coisas de configuração do spring como context: package-scan base-package = "..."
• Porém, a configuração xml substitui as anotações java quando se trata da configuração do fluxo (Spring Web Flow ou Lexaden Web Flow), pois é extremamente importante ver uma imagem maior de todo o processo de negócios. E parece complicado implementá-lo com a abordagem de anotações.

Eu prefiro combinar as duas abordagens - anotações java e xml mínimo essencial que minimizam o inferno da configuração.

Para o Spring Framework, gosto da ideia de poder usar a anotação @Component e definir a opção "component-scan" para que o Spring possa encontrar meus java beans, para que eu não precise definir todos os meus beans em XML nem em JavaConfig. Por exemplo, para java beans singleton sem estado que simplesmente precisam ser conectados a outras classes (via uma interface ideal), essa abordagem funciona muito bem. Em geral, para os beans Spring, na maioria das vezes, me afastei do DSL XML da Spring para definir beans, e agora sou a favor do uso de JavaConfig e Spring Annotations, porque você obtém uma verificação do tempo de compilação da sua configuração e algum suporte à refatoração que você não usa. Não fique com a configuração XML da Spring. Eu misturo os dois em alguns casos raros em que descobri que o JavaConfig / Annotations não pode fazer o que está disponível usando a configuração XML.

Para o Hibernate ORM (ainda não usei o JPA), ainda prefiro os arquivos de mapeamento XML porque as anotações nas classes de modelo de domínio, em certa medida, violam a Arquitetura Limpa, que é um estilo de arquitetura em camadas que adotei nos últimos anos. A violação ocorre porque exige que a camada principal dependa de coisas relacionadas à persistência, como as bibliotecas Hibernate ou JPA, e torna o POJOs do modelo de domínio um pouco menos persistente e ignorante. De fato, a camada principal não deve depender de nenhuma outra infraestrutura.

No entanto, se a Arquitetura Limpa não é sua "xícara de chá", posso ver que há definitivamente vantagens (como conveniência e manutenção) do uso de anotações Hibernate / JPA em classes de modelo de domínio sobre arquivos de mapeamento XML separados.