Eu praticamente faço tudo com Spring Framework. Ele simplesmente é o camisa 10 de todos os meus projetos nesses últimos 10 anos. Mas eu também não nego o benefício de usar um produto Java baseado em especificação. Quando você inicia sua carreira em Java, não dá muita bola para as especificações, até ter a experiência de migrar, trocar e/ou alterar uma solução e ver as consequências de usar uma especificação. A ficha caiu para mim quando migrei soluções de décadas usando banco de dados relacionais com JDBC e um outro com JPA. Demorei simplesmente algumas horas enquanto outros produtos de outras plataformas dentro da  mesma empresa, precisaram de 9 meses para fazer o mesmo. Migrei vários provedores de JSF em soluções web alguns bons anos também com muita facilidade e segurança. Tive outros exemplos legais também, que vou deixar para uma próxima.

O Spring é um produto proprietário e, sendo assim, você inevitavelmente acaba ficando amarrado com ele, sua versão e seus pacotes. Por exemplo: se você usa o modulo de IoC, vai acabar usando o import da anotação org.springframework.stereotype.Component. Quando essa anotação mudar de pacote, for substituída por uma outra ou você migrar de provedor de IoC, já era seu projeto! Quebra tudo e perde portabilidade.

“Seria possível usar o Spring e não ficar amarrado com ele?”

Sim, existem várias formas diferentes de fazer isso. Hoje, quero dar três dicas que tenho usado nos últimos anos para reduzir a dependência e amarração para o framework Spring.

1. Não use anotações proprietários de IoC

O modulo de IoC do spring funciona perfeitamente com a especificação CDI. Assim, você pode parar de usar anotações proprietárias @Component, @Controler, @Repository, @Service, @Autowire etc. Ao invés disso, use especificação CDI @Named, @Inject e @Resource. É claro que iremos perder os tratamentos de exceptions automáticas existente nas anotações spring e outros detalhes, mas você acaba retirando dependência desses pacotes de seu projeto. A maioria dos projetos tem tratamento de erros customizado e não dependente desses serviços. Então, analise e veja o que vale mais a pena.

Seguem abaixo alguns links sobre o assunto:

1. https://www.mkyong.com/spring3/spring-3-and-jsr-330-inject-and-named-example/
2. https://mobiarch.wordpress.com/2013/01/11/spring-di-and-cdi-comparative-study/

2. Não use anotações proprietários de escopo web

Quando você integra um JSF com container IoC do spring, é obrigado a usar as anotações de escopo proprietário para declarar ciclo de vida do seus managed beans. Você também não precisa usar elas.

Nas últimas versões do spring saiu um recurso muito bacana chamado de Meta Anotations Support. Resumidamente, é o ato de criar suas próprias anotações customizadas reusando e/ou evitando DRY de anotações spring dentro de seus beans. Usando esse recurso, você poderia criar suas próprias anotações de escopo, evitando espalhar repetidamente o import de pacotes proprietários do spring dentro de seus projetos.

Segue abaixo um exemplo meu:

Assim, nos seus managed beans, você evita o import dos org.springframework.context.annotations.Scope usando, então, sua própria anotação. Veja um exemplo de managed bean:

3. Não use anotações proprietários de transação

Uma das coisas que eu acredito ser mais utilizadas do módulo de transação do spring é a facilidade e a simplicidade da anotação @Transaction do pacote org.springframework.transaction.annotation. Com ela, o spring aplica AOP recursiva em suas transações de modo fácil e rápido. O que você não parou para pensar é que o seu domain model (DDD) acaba importando esse pacote proprietário em um bilhão de classes, ficando totalmente amarrado com o spring no uso desse serviço, furando o conceito mais básico e clássico DDD de um projeto que é a independência de produto, serviço ou framework. Pare de fazer isso! Aplique o mesmo caso do item 2 acima. Crie sua anotação de transação customizada e reuse no seu DDD. Segue um exemplo:

Assim, nos seus beans transacionais, você evita o import dos org.springframework.transaction.annotation, usando então sua própria anotação. Veja um exemplo:

Com essas três dicas simples, você elimina a maioria dos imports proprietários do spring framework para dentro do seu projeto, deixando seu código independente, mais flexível e limpo. Você continua usando o melhor e maior framework Java da história, e consegue manter as camadas do seu projeto independente de serviço e detalhes infraestruturais!

Até a próxima pessoal!