Ecossistema

Spring é um Framework open source desenvolvido para a plataforma Java baseado nos padrões de projetos inversão de controle e injeção de dependência. Sua estrutura é composta por módulos afins de reduzir a complexidade no desenvolvimento aplicações simples ou corporativa.

Spring versus JavaEE

Olhando um pouco a história, há muito, mas muito tempo atrás, o Java EE era realmente muito complicado e nem era necessário entrar numa discussão, usar o Spring era um caminho mais simples e mais fácil de evoluir. Aí chegou a versão 5 do Java EE e a discussão voltou a ficar um pouco mais quente.

Inversão de Controle

Inversion of Control ou IoC, trata-se do redirecionamento do fluxo de execução de um código retirando parcialmente o controle sobre ele e delegando-o para um container. O principal propósito é minimizar o acoplamento do código.

Sem IoC

Em nosso desenvolvimento éramos responsáveis pela instanciação e gestão dos objetos da aplicação

Com IoC

Agora um container cuida de todo este trabalho de criação e controle dos objetos da aplicação denominados de Component.

Injeção de Dependências

Injeção de dependência é um padrão de desenvolvimento com a finalidade de manter baixo o nível de acoplamento entre módulos de um sistema.

Beans

Objeto que é instanciado (criado), montado e gerenciado por um container através do princípio da inversão de controle.

Scopes

Controle da existência de nossos objetos Components da aplicação.

• Singleton: O container do Spring IoC define apenas uma instância do objeto.
• Prototype: Será criado um novo objeto a cada solicitação ao container.
• Request: Um bean será criado para cada requisição HTTP.
• Session: Um bean será criado para a sessão de usuário na Web.
• Global: Ou Application Scope cria um bean para o ciclo de vida do contexto da aplicação.

Autowired

Uma anotação (indicação) onde deverá ocorrer uma injeção automática de dependência.

• byName: É buscado um método set que corresponde ao nome do Bean.
• byType: É considerado o tipo da classe para inclusão do Bean.
• byConstrutor: Usamos o construtor para incluir a dependência.

Spring Boot

Enquanto que o Spring Framework é baseado no padrão de injeção de dependências, o Springboot foca na configuração automática.

Dado que a maior parte das configurações necessárias para o início de um projeto são sempre as mesmas, por que não iniciar um projeto com todas estas configurações já definidas?

Antes do Spring Boot

• Dependência individual
• Verbosidade
• Incompatibilidade de versões
• Complexidade de gestão
• Configurações complexas e repetitivas

Era Spring Boot

Starters

Os starters são dependências que agrupam outras dependências com um propósito em comum. Dessa forma, somente uma configuração é realizada no seu gerenciador de dependências.

Benefícios

• Coesão
• Versões compatíveis
• Otimização do tempo
• Configuração simples
• Foco no negócio

Alguns Starters

spring-boot-starter-*

• data-jpa: Integração ao banco de dados via JPA - Hibernate.
• data-mongodb: Interação com banco de dados MongoDB.
• web: Inclusão do container Tomcat para aplicações REST.
• web-services: Webservices baseados na arquitetura SOAP.
• batch: Implementação de JOBs de processos.
• test: Disponibilização de recursos para testes unitários como JUnit
• openfeign: Client HTTP baseado em interfaces
• actuator: Gerenciamento de monitoramento da aplicação.

Explicação Prática

Inversão de Controle (IoC)

O conceito de Inversão de Controle é um dos pilares do Spring e de muitos outros frameworks modernos. Em termos simples, IoC é um princípio de design que desloca a responsabilidade pela criação e gerenciamento de objetos do desenvolvedor para um framework ou container.

Como funciona?

Normalmente, em um sistema tradicional (sem IoC), o desenvolvedor cria objetos manualmente e gerencia suas dependências. Isso significa que ele decide quando e como criar os objetos, além de gerenciar a coordenação entre eles.

No entanto, com a Inversão de Controle, essa responsabilidade é delegada ao framework (no caso do Spring, ao Container IoC). O Spring passa a ser responsável por gerenciar o ciclo de vida dos objetos, instanciá-los, configurar suas dependências e fornecer esses objetos sempre que necessário. Essa mudança resulta em um código mais desacoplado, modular e de fácil manutenção.

Exemplo simples de IoC:

Antes de IoC:

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine();  // O desenvolvedor cria o objeto Engine
    }
}

Com IoC:

public class Car {
    private Engine engine;

    // O Spring injeta a dependência Engine
    public Car(Engine engine) {
        this.engine = engine;
    }
}

Aqui, a classe Car não cria o objeto Engine diretamente, mas depende de um mecanismo externo (o Spring, no caso) para fornecer o objeto Engine para ela.

Injeção de Dependência (DI)

A Injeção de Dependência é um padrão de design que implementa a Inversão de Controle (IoC). Ela permite que as dependências de um objeto sejam fornecidas a ele externamente, ao invés de ele mesmo gerenciar a criação e a injeção dessas dependências.

Em outras palavras, a DI permite que um objeto não precise construir seus próprios objetos de dependência. O Spring faz isso de duas formas principais:

• Injeção via construtor: O Spring injeta as dependências no momento em que o objeto é criado.
• Injeção via setter: O Spring injeta as dependências após o objeto ser criado, usando métodos setters.

Exemplo de Injeção de Dependência:

1. Injeção via construtor:

@Component
public class Car {
    private final Engine engine;

    // O Spring irá injetar o Engine automaticamente aqui
    public Car(Engine engine) {
        this.engine = engine;
    }
}

2. Injeção via setter:

@Component
public class Car {
    private Engine engine;

    // O Spring irá injetar o Engine automaticamente aqui
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
}

Na Injeção de Dependência, as dependências (como o objeto Engine) são passadas para a classe Car sem que a classe Car precise criar o objeto Engine. O Spring vai fornecer essas dependências automaticamente, o que torna o código mais flexível e mais fácil de testar.

Beans no Spring

No Spring, um Bean é simplesmente um objeto que é gerenciado pelo Spring Container (o IoC Container). O Spring se encarrega de criar, configurar e fornecer os beans para os outros componentes da aplicação, com base nas configurações definidas, seja por anotações (como @Component, @Service, @Repository, etc.) ou arquivos de configuração XML.

Os beans no Spring podem ser definidos de diversas formas:

• Com anotações:
  • @Component: Anotação genérica para qualquer tipo de bean.
  • @Service: Normalmente usada para beans de serviço (camada de negócios).
  • @Repository: Normalmente usada para beans de acesso a dados.
  • @Controller: Usada para beans de controle, tipicamente em aplicações web.
• Via XML: Em versões anteriores do Spring, era comum definir beans em arquivos de configuração XML, mas hoje em dia as anotações são mais populares e flexíveis.

Exemplo de Bean com Anotação:

@Component
public class Engine {
    // Implementação do bean Engine
}

Neste exemplo, a classe Engine é definida como um bean com a anotação @Component. O Spring gerenciará a criação e configuração desse bean.

Escopos dos Beans no Spring

Os escopos de um bean no Spring determinam o tempo de vida e a visibilidade do bean. O Spring oferece diversos escopos para seus beans, cada um com uma finalidade específica. Abaixo, vou detalhar os principais escopos:

a) Singleton (padrão)

• Escopo padrão no Spring. Quando um bean é criado com o escopo singleton, o Spring cria apenas uma instância desse bean durante toda a execução da aplicação. Essa instância é reutilizada sempre que o bean for solicitado.
• Uso: É ideal para beans que não têm estado ou que devem ser compartilhados por toda a aplicação, como serviços que lidam com regras de negócios.

Exemplo de bean singleton:

@Component
public class Engine {
    // O Spring cria apenas uma instância dessa classe durante toda a aplicação.
}

b) Prototype

• Quando um bean é configurado com o escopo prototype, o Spring cria uma nova instância do bean a cada solicitação. Isso significa que cada vez que o bean for injetado ou solicitado, uma nova instância será criada.
• Uso: Útil para beans que devem ter um estado próprio e independente para cada uso, como objetos que mantêm informações temporárias ou de sessão.

Exemplo de bean prototype:

@Component
@Scope("prototype")
public class Car {
    // O Spring cria uma nova instância dessa classe sempre que ela for solicitada.
}

c) Request

• Este escopo é utilizado em aplicações web. Quando um bean é configurado com o escopo request, ele é criado uma vez por requisição HTTP. Cada requisição para o servidor cria uma nova instância do bean.
• Uso: Usado para beans que precisam ser exclusivos para uma única requisição, como beans que lidam com dados de uma requisição HTTP específica.

Exemplo de bean request:

@Component
@Scope("request")
public class RequestHandler {
    // Criado uma vez para cada requisição HTTP
}

d) Session

• Similar ao escopo request, mas neste caso o bean é criado uma vez por sessão HTTP. Ou seja, ele vive enquanto a sessão do usuário estiver ativa.
• Uso: Usado para armazenar dados específicos de uma sessão de usuário, como informações de login ou preferências.

Exemplo de bean session:

@Component
@Scope("session")
public class UserSession {
    // Criado uma vez por sessão HTTP
}

e) Application

• O escopo application é utilizado em aplicações web e está relacionado ao ciclo de vida do contexto da aplicação. Ou seja, o bean existe enquanto a aplicação estiver em execução. Uma única instância é compartilhada em toda a aplicação.
• Uso: Ideal para beans que precisam ser compartilhados em toda a aplicação, mas não são necessariamente únicos por requisição ou por sessão.

Exemplo de bean application:

@Component
@Scope("application")
public class GlobalConfig {
    // Criado uma vez por aplicação
}

Conclusão

• Inversão de Controle (IoC) e Injeção de Dependência (DI) são princípios fundamentais do Spring que permitem a criação de aplicações desacopladas e mais fáceis de testar.
• Beans são os objetos gerenciados pelo Spring Container que podem ser configurados com diferentes escopos, de acordo com a necessidade da aplicação, como singleton, prototype, request, session, e application.
• Esses conceitos são a base para a construção de aplicativos Java modulares, escaláveis e fáceis de manter, especialmente em arquiteturas corporativas complexas.

Esses fundamentos são a chave para entender a flexibilidade e a eficiência que o Spring Framework oferece.

que da hora, me explica também a diferença entre Spring Framework e Spring Boot Claro! Vamos entender as diferenças entre o Spring Framework e o Spring Boot, dois componentes essenciais dentro do ecossistema Spring. Ambos são usados para construir aplicações Java, mas têm objetivos e abordagens distintas.