java - working - spring boot autowired bean




Uso de Spring @Autowired (6)

Aqui estão algumas experiências
Prós

  • Facilita a configuração porque podemos usar apenas a anotação @Autowire
  • Não quer usar métodos setter, então a classe será mais limpa

Contras

  • Firmemente casal para arquivo xml, mesmo que estamos usando DI
  • Difícil de encontrar a implementação (Mas se você está usando bons ides como intellij certeza que você pode se livrar disso)

A partir de minhas experiências pessoais, não usei muito a anotação @AutoWire, mas em casos de teste.

Quais são os prós e contras de usar o @Autowired em uma classe que será conectada pela Spring?

Só para esclarecer, estou falando especificamente sobre a anotação @Autowired , não sobre a fiação automática em XML.

Eu provavelmente não entendo, mas para mim isso quase parece um antipadrão - suas aulas começam a se tornar conscientes de que elas estão ligadas a uma estrutura de DI, ao invés de serem apenas POJOs. Talvez eu seja um comilão por punição, mas eu gosto de ter a configuração XML externa para beans, e eu gosto de ter fiações explícitas, então eu sei exatamente o que está ligado onde.


Estamos mudando do @Autowire de volta para a configuração XML em nosso grande projeto. O problema é o baixo desempenho do bootstrap. O scanner de autowiring carrega todas as classes do caminho de classe de pesquisa de autowiring, assim, muitas classes são carregadas ansiosamente durante a inicialização do Spring.


Eu realmente amo escrever com anotações, em vez de XML. De acordo com o manual do Spring e as últimas versões, o XML e o Annotation obtiveram o mesmo resultado.

Esta é minha lista

Pró:

  • Remover linha inútil do xml
  • Simplifique a depuração do código: quando você abre uma classe, você pode ler o que você tem na classe
  • Mais rápido desenvolvimento, um projeto com 400 ou mais linhas de XML é legível?

Contras:

  • Não é uma implementação Java padrão, mas você pode alternar para usar @Inject, que é uma API Java Standard, portanto, o bean permanece um Pojo
  • Você não pode simplesmente usar em todos os lugares, conexão db e assim por diante, mas é apenas uma opinião, eu prefiro ter um lugar onde leia toda a configuração.

Minha opinião sobre esse assunto é que, a configuração xml reduz a clareza do código, especialmente em sistemas grandes.

Anotações como @Component tornam as coisas ainda piores. Ele orienta os desenvolvedores a tornar os objetos mutáveis, já que as dependências não podem mais ser finalizadas, já que os construtores padrão precisam ser fornecidos. As dependências precisam ser injetadas por meio de setter público ou não controladas por meio do @Autowired. [ainda pior injeção de dependência é comprometida com classes que instanciam suas dependências, eu ainda vejo isso em código recém-escrito!]. Por descontrolado quero dizer, em grandes sistemas, quando múltiplas implementações (ou crianças) do tipo estão disponíveis, fica muito mais envolvido para entender qual das implementações foi @Autowired, uma complexidade que dificulta muito a investigação de bugs. Isso também significa que, supostamente, você tem um perfil para o ambiente de teste e outro para produção, seus erros de produção só acontecem quando dói mais - na produção, em vez de ser capaz de identificar os bugs no ambiente de teste, ou melhor ainda tempo de compilação!

Eu mantenho o meio termo onde eu declaro minhas classes de configuração, (configuração Spring baseada em java usando @Configuration)

Eu declaro todos os meus beans explicitamente na (s) classe (s) de configuração. Eu só uso @Autowired na (s) classe (s) de configuração, o objetivo é limitar a dependência do Spring para a (s) classe (s) de configuração

O @Configuration reside em um pacote específico, que é o único lugar onde a verificação por mola é executada. (Isso acelera o tempo de início substancialmente em grandes projetos)

Eu me esforço para tornar todas as minhas classes imutáveis, especialmente o objeto de dados, JPA, Hibernate e Spring, assim como muitas bibliotecas de serialização parecem minar isso. Afasto-me de qualquer coisa que me force a fornecer setters, ou remover a palavra-chave final da minha declaração de propriedade.

Reduzir as possibilidades de alterar objetos depois que eles são criados, reduz substancialmente os erros no sistema grande, bem como reduz o tempo para encontrar um bug quando existe um.

Parece também que força o desenvolvedor a projetar melhor a interação entre as diferentes partes do sistema. Problemas e erros tornam-se cada vez mais erros de compilação, o que reduz o desperdício de tempo e melhora a produtividade.


Para minha compreensão, @Autowired é o melhor para usar enquanto se refere a referência de interface e usar suas funções de substituição, mas eu só acho que o problema é que às vezes é atribuído a nulo em tempo de execução.


Por muito tempo eu acreditei que havia um valor em ter uma "configuração declarativa e centralizada" como os arquivos xml que todos nós costumávamos usar. Então percebi que a maioria das coisas nos arquivos não era configuração - nunca foi alterada depois do desenvolvimento, nunca. Então percebi que "centralizado" só tem valor em sistemas bem pequenos - somente em sistemas pequenos você conseguirá agregar um arquivo de configuração como um todo . E qual é realmente o valor de entender a fiação como um todo, quando as mesmas "fiações" são praticamente duplicadas por dependências no código? Então, a única coisa que eu mantenho são metadados (anotações), que ainda são meio declarativos. Eles nunca mudam em tempo de execução e nunca são dados de "configuração" que alguém vai mudar na hora - então acho que mantê-lo no código é legal.

Eu uso toda a fiação automática o máximo que posso. Eu amo isso. Eu não vou voltar para a primavera de estilo antigo a menos que ameaçado no ponto da arma. Minhas razões para preferir totalmente o @Autowired mudaram com o tempo.

No momento, acho que a razão mais importante para usar o autowiring é que há menos uma abstração em seu sistema para rastrear. O "nome do bean" foi efetivamente eliminado. Acontece que o nome do bean existe apenas por causa do xml. Assim, uma camada completa de indirecções abstratas (onde você enviaria o bean-name "foo" para o bean "bar") desapareceu. Agora conecto a interface "Foo" diretamente ao meu bean e a implementação é escolhida pelo perfil de tempo de execução. Isso me permite trabalhar com código ao rastrear dependências e implementações. Quando vejo uma dependência autowired no meu código, basta pressionar a tecla "ir para a implementação" no meu IDE e surge a lista de implementações conhecidas. Na maioria dos casos, há apenas uma implementação e sou direto para a aula. Não pode ser muito mais simples do que isso, e eu sempre sei exatamente qual implementação está sendo usada (eu afirmo que o oposto está mais próximo da verdade com a fiação xml - engraçado como sua perspectiva muda!)

Agora você poderia dizer que é apenas uma camada muito simples, mas cada camada de abstração que adicionamos aos nossos sistemas aumenta a complexidade. Eu realmente não acho que o xml tenha adicionado algum valor real a qualquer sistema com o qual trabalhei.

A maioria dos sistemas com os quais já trabalhei tem apenas uma configuração do ambiente de tempo de execução de produção. Pode haver outras configurações para teste e assim por diante.

Eu diria que o autowiring completo é o ruby-on-rails da primavera: ele abraça a noção de que há um padrão de uso normal e comum que a maioria dos casos de uso segue. Com a configuração XML, você permite muito uso de configuração consistente / inconsistente que pode ou não ser intencional. Eu vi tanta configuração xml ir ao mar com inconsistências - ele é refatorado junto com o código? Não pensei. Essas variações existem por um motivo? Geralmente não.

Dificilmente usamos qualificadores em nossa configuração e encontramos outras maneiras de resolver essas situações. Essa é uma clara "desvantagem" que encontramos: Alteramos um pouco a maneira como codificamos para fazer com que ela interaja mais suavemente com autowiring: um repositório de clientes não implementa mais a interface genérica Repository<Customer> , mas criamos uma interface CustomerRepository que estende o Repository<Customer> . Às vezes também há um truque ou dois quando se trata de subclassificação. Mas geralmente apenas nos aponta na direção de uma tipificação mais forte, o que eu acho quase sempre é uma solução melhor.

Mas sim, você está ligando a um estilo específico de DI que a maioria das primaveras faz. Nós nem mesmo fazemos setters públicos para dependências (Então você poderia argumentar que somos +1 no departamento de encapsulamento / ocultação de informações) Ainda temos alguns xml em nosso sistema, mas o xml basicamente contém apenas as anomalias. A autowiring completa integra-se perfeitamente ao xml.

A única coisa que precisamos agora é que o @Component , @Autowired e o resto sejam incluídos em um JSR (como o JSR-250 ), então não precisamos nos conectar com o Spring. É assim que as coisas têm acontecido no passado (o java.util.concurrent stuff vem à mente), então eu não ficaria totalmente surpreso se isso acontecesse novamente.





autowired