O que faz o framework Spring? Devo usá-lo? Por que ou por que não?

230

Então, estou iniciando um novo projeto em Java e estou pensando em usar o Spring. Por que estou considerando a primavera? Porque muitas pessoas me dizem que eu deveria usar o Spring! Sério, toda vez que eu tentei fazer com que as pessoas explicassem o que exatamente é Spring ou o que ele faz, elas nunca podem me dar uma resposta direta. Eu verifiquei as introduções no site SpringSource, e elas são realmente complicadas ou realmente voltadas para o tutorial, e nenhuma delas me dá uma boa idéia do porquê eu deveria usá-lo, ou como isso facilitará minha vida. Às vezes as pessoas usam o termo "injeção de dependência", o que só me confunde ainda mais, porque acho que tenho uma compreensão diferente do significado desse termo.

Enfim, aqui está um pouco sobre meu histórico e meu app:

Tenho desenvolvido em Java por um tempo, fazendo desenvolvimento web de back-end. Sim, faço uma tonelada de testes unitários. Para facilitar isso, normalmente faço (pelo menos) duas versões de um método: uma que usa variáveis de instância e uma que usa apenas variáveis que são passadas para o método. Aquele que usa variáveis de instância chama o outro, fornecendo as variáveis de instância. Quando chega a hora de testar a unidade, eu uso o Mockito para simular os objetos e, em seguida, fazer chamadas para o método que não usa variáveis de instância. Isso é o que eu sempre entendi como "injeção de dependência".

Meu aplicativo é bem simples, do ponto de vista do CS. Projeto pequeno, 1-2 desenvolvedores para começar. Principalmente operações do tipo CRUD com um monte de buscas. Basicamente, um monte de serviços web RESTful, além de um front-end web e, eventualmente, alguns clientes móveis. Estou pensando em fazer o front-end em HTML / CSS / JS / JQuery, então não há planos reais de usar o JSP. Usando o Hibernate como um ORM e o Jersey para implementar os webservices.

Eu já comecei a codificar e estou ansioso para ter uma demonstração que eu possa comprar e ver se alguém quer investir. Então, obviamente, o tempo é da essência. Eu entendo que Spring tem bastante a curva de aprendizado, mais parece que isso requer uma grande quantidade de configuração XML, que eu normalmente tento evitar como a praga. Mas se puder facilitar a minha vida e (especialmente) se conseguir fazer o desenvolvimento e o teste mais rápido, estou disposto a morder a bala e aprender a Primavera.

Então por favor. Me educar. Devo usar a primavera? Por que ou por que não?

    
por sangfroid 12.07.2011 / 20:54
fonte

7 respostas

105

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.

    
por 13.07.2011 / 21:40
fonte
64

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ê.

Eu poderia insistir para sempre sobre as maravilhas do Spring, mas talvez a melhor coisa a fazer seja testar um simples pico de código no qual você tenta conectar um serviço web RESTful para extrair dados de um DAO injetado que suporta transações.

    
por 12.07.2011 / 22:40
fonte
28
Em primeiro lugar, sua compreensão da injeção de dependência não é fundamentalmente errada, mas completamente diferente do que a maioria das pessoas quer dizer quando usa o termo. O que você descreve é uma maneira bastante estranha e pouco convencional de obter testabilidade. Eu aconselho você a se afastar disso, já que outros desenvolvedores ficarão bastante intrigados com esse tipo de código.

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.

Em segundo lugar, o Spring não é apenas injeção de dependência, embora essa seja sua principal funcionalidade. Ele também fornece transações declarativas, agendamento de tarefas, autenticação e um monte de outras funcionalidades (incluindo um framework web MVC completo) que você pode precisar. Existem outros frameworks que fornecem a mesma funcionalidade, mas além do Spring, apenas o Java EE os integra.

    
por 12.07.2011 / 23:34
fonte
19

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.

por 15.07.2011 / 13:02
fonte
13

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.

    
por 15.06.2015 / 13:35
fonte
12

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?

    
por 15.06.2012 / 11:04
fonte
4

É 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

    
por 12.07.2011 / 21:13
fonte