Configuração de DI vs xml baseada em anotação de primavera?

Recentemente, em nossa equipe, começamos a discutir o uso de annotations de mola no código para definir dependencies de primavera. Atualmente estamos usando context.xml para definir nossas dependencies. Você me daria algumas pistas para qualquer abordagem e quando é melhor usá-la?

Edit: Eu sei que isso parece uma questão duplicada para um mais geral, mas estou interessado nos impactos de annotations vs configuração para injeção de dependência somente, que eu acredito que teria respostas e atitude diferentes do que a questão geral.

Depois de ler alguns posts relacionados aqui e ter mais discussões na equipe, chegamos às seguintes conclusões. Espero que seja útil para os outros aqui.

Sobre a configuração XML (que estamos usando até agora), decidimos mantê-la para dependencies de bibliotecas (desenvolvidas por nós ou por terceiros). As bibliotecas, por definição, devem fornecer apenas certas funcionalidades e podem ser usadas em vários cenários, que nem sempre envolvem DI. Portanto, o uso de annotations em nossos projetos de biblioteca trará dependencies da estrutura de DI (Spring no nosso caso) para a biblioteca, e isso seria inútil quando a biblioteca é usada sem DI. Ter dependencies extras não é considerado uma boa prática entre nossa equipe (em geral, IMHO). Quando estamos montando um aplicativo, o aplicativo possui as dependencies DI necessárias e a injeção de classs de bibliotecas é feita pela configuração. O XML também é bom para fornecer implementações simuladas para muitos componentes, sem recompilar os módulos que os utilizarão. Isso nos dá flexibilidade ao testar ou executar em ambiente local ou de produção.

Sobre as annotations , decidimos que podemos nos beneficiar delas quando os componentes injetados não variarem, e não haverá cenários em que diferentes implementações de um componente seriam usadas. Decidimos que as annotations serão muito úteis para pequenos módulos / aplicativos com funcionalidade clara, que não irão mudar ou suportar implementações diferentes. Esses módulos quase podemos usar fora da checkbox em projetos diferentes, sem escrever o tedioso XML. No entanto, concordamos que esses módulos devem ter as dependencies descritas em nossa documentação técnica, para que, ao montar o aplicativo inteiro, seja possível ter uma idéia dessas dependencies sem rolar pelo código ou até carregar o módulo no IDE. Ainda assim, parece que as annotations exigirão que o módulo seja um pouco maduro sobre quais dependencies ele usará. Isso também é aplicável para as configurações de class java, que é a alternativa moderna de Spring dos contextos XML.

Em geral, se nossas dependencies puderem variar para diferentes cenários, ou se um módulo puder ser usado com componentes diferentes, decidimos manter o XML e não codificar quaisquer dependencies em tal módulo. Claramente, deve haver um equilíbrio entre as duas abordagens, e uma idéia clara para os usos.


Uma atualização importante sobre a abordagem mista. Recentemente, tivemos um caso com uma estrutura de teste que criamos para nossa equipe de QA, que exigia dependencies de outro projeto. A estrutura foi projetada para usar a abordagem de anotação e as classs de configuração do Spring, enquanto o projeto referenciado possui alguns contextos xml que precisávamos fazer referência. Infelizmente, as classs de teste (usamos o org.testng com suporte a mola) só podiam trabalhar com classs de configuração xml ou java, não ambas.

Esta situação ilustra um caso em que ambas as abordagens se chocam e claramente, uma deve ser descartada. No nosso caso, migramos a estrutura de teste para usar contextos xml spring, mas outros usos poderiam implicar o contrário.

Pela minha experiência, eu preferiria (ou melhor, ser forçado por limitações) a usar uma combinação de XML e DI baseada em anotação. Se eu precisar injetar um mapa de elementos dentro de um bean, eu teria que definir um util: map e autowire. Além disso, eu preciso usar XML DI para injetar datasource no sessionFactory se eu tiver várias fonts de dados e assim por diante. Então, uma combinação de ambos seria correspondida.

Eu prefiro o uso do componente-scan para autodetectar os serviços e Dao. Isso reduz muito a configuração (reduzimos os arquivos de configuração em cerca de 50% ao alternar para a verificação de componentes). A DI baseada em anotação suporta tanto byName (@Resource) quanto byType (@Autowired).

Em suma meu conselho para ser para ir para um dispositivo de ambos. Eu sinto que mais suporte a annotations estará definitivamente em cartões nos próximos lançamentos do Spring.

Dê uma olhada nesta resposta aqui: Configuração Xml versus configuração baseada em Anotação

Uma citação curta diretamente de lá:

Anotações têm seu uso, mas elas não são o único marcador 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 de seu aplicativo. Isso deixa as dependencies do código longe do código que o estará usando, em contraste, usando algum tipo de anotação no código que precisa das dependencies para tornar 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 o sentido, já que essa é uma informação que um programador provavelmente desejaria saber.

EDIT: Além disso, dê uma olhada nas respostas aqui: dependency injection de Java: XML ou annotations Eles provavelmente direcionar a área de seu interesse muito melhor.

Algumas vantagens do uso da configuração XML :

  1. A configuração XML está em um lugar, em vez de estar espalhada por todo o código-fonte no caso de annotations. Algumas pessoas podem argumentar que IDEs como STS permitem que você olhe para todas as annotations baseadas em configurações em um único lugar, mas eu nunca gosto de ter dependencies em IDEs.
  2. É preciso um pouco mais de esforço para gravar a configuração XML, mas ela economiza muito tempo depois quando você procura por dependencies e tenta entender o projeto.
  3. XML mantém a configuração bem organizada e simples. Por isso, é mais fácil de entender, ajuda os membros da equipe relativamente inexperientes a se familiarizarem rapidamente.
  4. Permite que você altere a configuração sem precisar recompilar e reimplantar o código. Então é melhor quando se trata de suporte à produção.

Portanto, a configuração XML resumida exige um pouco mais de esforços, mas você economiza muito tempo e dor de cabeça mais tarde em grandes projetos.

De minhas próprias annotations de experiência melhor que configuração de xml. Eu acho que em qualquer caso você pode replace o xmls e usar annotations. Também o Spring 4 nos fornece um suporte enorme para annotations, podemos replace a segurança de xml para annotations, etc., portanto, não teremos 100 linhas xml, mas 10 linhas de código Java.

Intereting Posts