What does the Spring framework do? Should I use it? Why or why not?

O Spring é um framework que ajuda você a "conectar" diferentes componentes juntos. É mais útil em casos em que você tem muitos componentes e você pode decidir combiná-los de maneiras diferentes, ou facilitar a troca de um componente por outro, dependendo de configurações ou ambientes diferentes.

This is what I've always understood "dependency injection" to be.

Eu sugeriria uma definição diferente:

"Projete seus objetos para que eles dependam de uma força externa para fornecer a eles o que eles precisam, com a expectativa de que essas dependências sejam sempre injetadas antes que alguém as peça para começar a fazer seus trabalhos habituais. "

Compare isso com: "Cada objeto é responsável por sair e encontrar tudo e todos de que precisa ao iniciar".

it looks like it necessitates a whole bunch of XML configuration

Bem, a maior parte do material XML (ou baseado em anotações) está dizendo coisas para o Spring como:

• Quando alguém perguntar por "HammerStore", quero que você crie uma instância de example.HammerStore e a retorne. Armazene em cache a instância da próxima vez, pois é necessário apenas uma loja.
• Quando alguém pergunta por "SomeHammer", quero que você peça uma "HammerStore" e retorne o resultado do método makeHammer() da loja. Não não armazena este resultado em cache.
• Quando alguém solicita "SomeWrench", quero que você crie uma instância de example.WrenchImpl , use a configuração gaugeAmount e coloque-a na propriedade setWrenchSize() da instância. Não armazene em cache o resultado.
• Quando alguém pergunta por "LocalPlumber", desejo criar uma instância de example.PlumberImpl . Coloque a string "Pedro" em seu método setName() , coloque um "SomeHammer" em seu método setHammer() e coloque um "SomeWrench" em seu método setWrench() . Devolva o resultado e armazene em cache o resultado para mais tarde, pois só precisamos de um canalizador.

Dessa forma, o Spring permite que você conecte seus componentes, identifique-os, controle seus ciclos de vida / armazenamento em cache e altere o comportamento com base na configuração.

To facilitate [testing] I typically make (at least) two versions of a method : one that uses instance variables, and one that only uses variables that are passed in to the method.

Isso soa como muita sobrecarga por não ter muito benefício para mim. Em vez disso, faça com que suas variáveis de instância tenham protected ou visibilidade do pacote e localize a unidade testes dentro do mesmo pacote com.mycompany.whatever . Dessa forma, você pode inspecionar e alterar as variáveis de instância sempre que quiser durante o teste.

Primeiro, o que é injeção de dependência?

Simples. Você tem uma classe, tem um campo privado (definido como null) e você declara um setter público que fornece o valor para esse campo. Em outras palavras, a dependência da classe (o campo) está sendo injetada por uma classe externa (via setter). É isso aí. Nada mágico.

Em segundo lugar, o Spring pode ser usado sem XML (ou muito pouco)

Se você mergulhar no Spring 3.0.5.GA ou superior, poderá usar o suporte de injeção de dependência do JDK6 +. Isso significa que você pode conectar dependências usando as anotações @Component e @Resource .

Por que usar a Spring?

Obviamente, a injeção de dependência promove testes de unidade muito fáceis, já que todas as suas classes têm setters para as dependências importantes e podem ser facilmente ridicularizadas usando sua estrutura de simulação favorita para fornecer o comportamento necessário.

Além disso, o Spring também fornece muitos modelos que funcionam como classes base para o uso das tecnologias padrão JEE. Por exemplo, o JdbcTemplate funciona bem com o JDBC, o JpaTemplate faz coisas boas com o JPA, o JmsTemplate torna o JMS bastante simples. O RestTemplate é simplesmente incrível em sua simplicidade. Por exemplo:

RestTemplate restTemplate = new RestTemplate();
MyJaxbObject o = restTemplate.getForObject("https://secure.example.org/results/{param1}?param2={param2}",MyJaxbObject.class,"1","2");

e pronto. Os parâmetros são injetados e você só precisa fornecer anotações JAXB para MyJaxbObject. Isso não deve levar tempo algum se você os gerou automaticamente a partir de um XSD usando o plugin Maven JAXB. Note-se que não havia fundição acontecendo lá, nem havia a necessidade de declarar um marshaller. Tudo é feito por você.

Injeção de dependência como é geralmente entendida (e implementada pelo Spring) significa que as dependências de uma classe (por exemplo, uma fonte de dados JDBC) não são buscadas pela própria classe, mas "injetadas" por um container quando a instância é criada. Então você não tem duas versões de cada método que usa a fonte de dados; em vez disso, você tem uma configuração de injeção de dependência onde a fonte de dados "real" é injetada e uma onde uma simulação é injetada. Ou, se a injeção ocorrer por meio do construtor ou de um getter, o código de teste pode fazer a injeção explicitamente.

Por que você quer usar o Spring, você pode lê-lo em link

Em resumo:

• Aplicativos J2EE tendem a conter quantidades excessivas de "encanamento" código. Muitas análises de código revelam repetidamente uma alta proporção de código que não faz nada: código de pesquisa JNDI, objetos de transferência, tente / capture blocos para adquirir e liberar recursos JDBC. . . . Escrita e manter esse código de encanamento prova uma grande perda de recursos que deve ser focado no domínio de negócios do aplicativo.

• Muitos aplicativos J2EE usam um modelo de objeto distribuído em que isso é inapropriado. Esta é uma das principais causas do excesso de código e duplicação de código. Também é conceitualmente errado em muitos casos; aplicações distribuídas internamente são mais complexas do que co-localizadas aplicações e, frequentemente, com muito menos desempenho. Claro, se o seu requisitos de negócios ditam uma arquitetura distribuída, você precisa implementar uma arquitetura distribuída e aceitar o trade-off que incurs (e Spring oferece recursos para ajudar em tais cenários). Mas você não deve fazer isso sem uma razão convincente.

• O modelo de componente EJB é extremamente complexo. EJB foi concebido como uma maneira de reduzir a complexidade ao implementar a lógica de negócios no J2EE aplicações; não conseguiu este objetivo na prática.

• O EJB é usado em excesso. EJB foi essencialmente projetado para internamente distribuído, aplicativos transacionais. Enquanto quase todos os não-triviais as aplicações são transacionais, a distribuição não deve ser construída o modelo de componente básico.

• Muitos "padrões de design J2EE" não são, na verdade, padrões de design, mas soluções alternativas para limitações tecnológicas. Uso excessivo de distribuição e O uso de APIs complexas, como o EJB, gerou muitos questionamentos Padrões de design; é importante examinar isso criticamente e olhar para abordagens mais simples e mais produtivas.

• Aplicativos J2EE são difíceis de testar na unidade. As APIs do J2EE e especialmente, o modelo de componente EJB, foram definidos antes do ágil o movimento decolou. Assim, o seu design não leva em consideração facilidade de testes unitários. Através de APIs e contratos implícitos, é surpreendentemente difícil testar aplicativos baseados em EJB e muitos outras APIs do J2EE fora de um servidor de aplicativos. Ainda teste unitário fora de um servidor de aplicativos é essencial para alcançar alto teste cobertura e para reproduzir muitos cenários de falha, como a perda de conectividade com um banco de dados. Também é vital assegurar que os testes pode ser executado rapidamente durante o processo de desenvolvimento ou manutenção, minimizar tempo improdutivo à espera de reimplantação.

• Determinadas tecnologias J2EE simplesmente falharam. O principal criminoso aqui é entidade feijão, que provaram pouco desastrosa para produtividade e em suas restrições na orientação a objetos.

What does the Spring framework do?

O Spring é como hoje não só, o que era conhecido como um framework simples, é um ecossistema completo.

Tópicos abordados pelo ecossistema da primavera:

• Spring Framework (por exemplo, injeção de dependência, AOP ...)

• Spring Cloud

• Dados da primavera

• Spring Security

• Spring Batch

• Spring Social

Veja aqui para uma cobertura completa do ecossistema. É possível selecionar os projetos, para que você possa usar o Google Guice para DI e, por exemplo, Spring Security para lidar com as coisas relacionadas à segurança. Você não precisa comprar todo o ecossistema.

O próprio framework Spring abrange hoje principalmente

• Injeção de dependência

• Programação orientada a aspectos, incluindo o gerenciamento de transações declarativas do Spring

• Aplicativo Web Spring MVC e estrutura de serviços da web RESTful

• Suporte básico para JDBC, JPA, JMS

Fonte spring.io

Em geral, você poderia dizer que o Spring é uma coleção de Padrões e Práticas implementadas no código, o que poderia ajudar a melhorar ou acelerar o ciclo de desenvolvimento do aplicativo.

O que é mais conhecido (o core-framework) é a capacidade no campo de injeção de dependência . O próprio Spring tem, o que é chamado Inversão do contêiner de controle ou curto Contêiner IoC ou ainda mais curto o contêiner (para o qual" mola "às vezes é usado como sinônimo).

O que é injeção de dependência?

Injeção de dependência significa que seu objeto recebe toda dependência de outros objetos através de um mecanismo externalizado.

Digamos, você tem um carro, a maneira típica, é implementado é:

public class Car {

    Engine e;

    public Car() { 
        e = new Engine(); 
    }

}

O objeto carro é dependente de um motor. Como o motor é implementado como um membro do carro, ele não pode ser trocado por, e. um mecanismo de teste.

Agora injeção de dependência entra em ação:

public class Car {

    Engine e;

    public Car(Engine e) { 
        this.e = e; 
    }

}

Depois disso, você pode trocar de mecanismo. O que você vê acima é chamado injeção de construtor . Existem outros tipos, como por ex. setter -injeção ou método -injeção. Como a Spring te ajuda com isso? O Spring permite marcar componentes a serem injetados com a anotação @Autowired e faz a fiação do objeto injetado automaticamente - é provável que o componente que você deseja injetar tenha dependências próprias. Injetáveis - por assim dizer - são marcados via @Component

public class Car {

    Engine e;

    @Autowired
    public Car(Engine e) { 
        this.e = e; 
    }

}

Mas esse é apenas um dos muitos recursos que a Spring tem para oferecer.

Should I use Spring? Why or why not?

Como a Spring não é muito intrusiva e oferece muitos auxílios, você deve considerar o uso da mola. Especialmente para novos projetos, Spring Boot é muito atraente. start.spring.io oferece uma interface fácil de usar point'n'click para gerar um modelo de projeto para começar. É possível usar curl para recuperar um modelo:

curl start.spring.io

  .   ____          _            __ _ _
 /\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _' | \ \ \ \
 \/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

:: Spring Initializr ::  https://start.spring.io

This service generates quickstart projects that can be easily customized.
Possible customizations include a project's dependencies, Java version, and
build system or build structure. See below for further details.

The services uses a HAL based hypermedia format to expose a set of resources
to interact with. If you access this root resource requesting application/json
as media type the response will contain the following links:
+-----------------+-----------------------------------------+
| Rel             | Description                             |
+-----------------+-----------------------------------------+
| gradle-build    | Generate a Gradle build file            |
| gradle-project  | Generate a Gradle based project archive |
| maven-build     | Generate a Maven pom.xml                |
| maven-project * | Generate a Maven based project archive  |
+-----------------+-----------------------------------------+

...

Por outro lado, estruturas como faísca ou dropwizard ofereça um bom ponto de partida para a criação rápida de aplicativos da web também.

Costumavamos criar aplicativos e serviços da Web simples, eficientes e rápidos usando apenas Java, Servlets e JSP, html e xml, API do JDBC. Foi bom o suficiente; O JUnit foi uma boa ferramenta para testar. Descansamos com facilidade que nosso código funcionou.

O Hibernate surgiu para simplificar o SQL e permitir o verdadeiro mapeamento das tabelas do Banco de Dados com objetos Java, permitindo que os relacionamentos hierárquicos sejam refletidos no Mapeamento de Relações de Objeto ou no ORM, como nós o chamamos. Eu amei. Especialmente que não precisávamos mapear o ResultSet de volta para um objeto Java ou tipo de dados.

Struts apareceu para adicionar o padrão Model View Controller aos nossos aplicativos da Web, foi bom.

Os EJBs eram uma enorme sobrecarga e a dor e as anotações faziam o código parecer um arranhão de galinha e agora a Primavera surgiu para nós inocentes. Parece apenas exagero para mim.

Por exemplo, agora empacotamos nossa url jdbc simples, user, passamos para jdbc.properties primeiro, depois para as propriedades hibernate em segundo e depois para Spring beans pela terceira vez!

Versus all that, considere obter uma conexão onde você precisa é realmente tão simples como mostrado abaixo em java puro, que é o que nós realmente estamos fazendo depois de passar por todo aquele material de ar quente com Spring:

Connection connection = DriverManager.getConnection(url, user, pass);

Isso é em si mesmo auto-explicativo que é uma grande rodada e rodando e rodando para fazer uma coisa simples, rápida e fácil, sem outros grandes benefícios realmente. É como embrulhar toneladas e toneladas de papel de presente em torno de um belo presente que é tudo o que você realmente guarda de qualquer maneira.

Outro exemplo é uma atualização em lote. Com o Spring, é complicado envolver algumas classes, interfaces antes de poder usar o JdbcTemplate para fazer uma atualização em lote. Com jdbc simples, simplesmente:

Statement statement = connection.createStatement();
statement.addBatch(sqlquery);
statement.executeBatch();

Não pode ser mais simples ou mais rápido que isso.

Eu não apoio esse framework. Desculpa. Quem na terra quer injeções toda vez que precisar de alguma coisa?

É um framework escrito em Java com muitas coisas incluídas para tornar sua aplicação web funcional (por exemplo, suporte para internacionalização). Ele também fornece uma boa maneira de estruturar seu aplicativo em camadas. Use-o, você economizará muito tempo a longo prazo.

Um bom livro para aprender sobre o Spring é: Expert Spring MVC e Web Flow