Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Aprenda IoC e DI | Fundamentos do Spring Boot
Spring Boot Backend

bookIoC e DI

O Spring Container é o componente central do Spring Framework responsável pela criação, configuração e ciclo de vida dos beans (objetos) dentro de uma aplicação. O Spring Container também é conhecido como IoC container.

Uma dependência refere-se a qualquer classe que exige que outros objetos sejam injetados para funcionar corretamente, e essa cadeia de dependências pode continuar indefinidamente. Normalmente, para criar um objeto com dependências, é necessário inicializá-lo explicitamente usando o operador new e especificar a classe.

É nesse ponto que o Spring atua com Inversion of Control e Dependency Injection. O conceito é que o Spring assume a responsabilidade de criar e gerenciar as dependências. Em vez de manualmente configurar a inicialização, basta anotar as classes necessárias, e o Spring as cria automaticamente e gerencia seu ciclo de vida dentro do seu contexto.

Uma dessas anotações é @Component, que deve ser colocada acima da classe.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Essa abordagem desloca o foco do gerenciamento manual de dependências, permitindo que desenvolvedores se concentrem na lógica de negócio enquanto o Spring lida com as tarefas de infraestrutura relacionadas à criação de objetos e ao gerenciamento de dependências.

Como o contêiner Spring funciona?

Quando a aplicação é iniciada, o Spring Container é inicializado. Ele começa escaneando as classes em busca de anotações como @Component, @Service, @Repository e @Configuration.

@Component é uma anotação geral que torna uma classe gerenciada pelo Spring, permitindo que ela seja registrada como um bean.

@Service, @Repository e @Controller são versões mais especializadas de @Component. Elas cumprem o mesmo propósito, mas indicam o papel específico da classe: @Service para lógica de negócio, @Repository para acesso a dados e @Controller para tratamento de requisições web.

@Configuration é utilizada para classes que contêm definições de beans e configuração da aplicação.

Ao marcar uma classe com uma dessas anotações, garante-se que ela se torne um bean dentro do contexto Spring.

Após a identificação das classes, o container procede à criação de instâncias dessas classes anotadas, transformando-as efetivamente em beans que o contexto do Spring gerencia ao longo do ciclo de vida da aplicação.

À medida que esses beans são criados, o container gerencia automaticamente suas dependências por meio da Injeção de Dependências. Esse processo permite que as classes recebam as dependências necessárias sem a necessidade de criá-las ou localizá-las explicitamente, otimizando o processo de desenvolvimento.

Injeção de Dependências (DI)

Primeiro, o Spring Container adiciona ao seu contexto os beans (classes) marcados com as anotações @Component, @Service, @Repository e @Configuration. Após isso, ele fornece esses beans para quaisquer objetos que os solicitarem.

Exemplo da Vida Real

Imagine o desenvolvimento de uma loja online. Existe uma classe OrderService que gerencia pedidos e uma classe PaymentService que processa pagamentos. Em vez de criar manualmente uma instância de PaymentService dentro de OrderService, é possível permitir que o Spring Container crie e injete PaymentService em OrderService.

OrderService.java

OrderService.java

PaymentService.java

PaymentService.java

copy

              
1234567891011121314

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Na classe OrderService, haverá um campo paymentService que é inicializado com o tipo exato necessário (PaymentService). Observe que não inicializamos explicitamente este objeto, o Spring fez isso por nós!

Se não tivéssemos anotado PaymentService com @Service, esse bean não teria sido adicionado ao contexto do Spring, e ocorreria um erro indicando que o Spring não encontrou tal bean.

@Autowired

Também é possível utilizar a anotação @Autowired, que instrui o Container do Spring a injetar o objeto apropriado no campo.

OrderService.java

OrderService.java

copy

              
123456789101112131415

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

No Spring, a partir da versão 4.3, o uso da anotação @Autowired não é mais obrigatório ao injetar dependências por meio de um construtor se houver apenas um construtor na classe. O Spring determina automaticamente que este construtor deve ser utilizado para a injeção de dependências.

Quais são os Diferentes Tipos de Bean?

Imagine que você tem uma única máquina de café em uma cafeteria. Sempre que um cliente pede um café, o barista utiliza essa mesma máquina de café para preparar cada xícara. A máquina de café é sempre a mesma, não uma nova para cada pedido.

Da mesma forma, no Spring, quando você injeta um bean do contexto Spring, o Spring fornece sempre a mesma instância desse bean. Isso é conhecido como o escopo singleton. Assim como a máquina de café na cafeteria, o Spring garante que você sempre receba o mesmo objeto em vez de criar um novo a cada vez.

Singleton

Podemos definir o tipo utilizando a anotação @Scope e especificar singleton nos atributos.

SingletonService.

SingletonService.

copy

              
12345

            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java

PrototypeService.java

copy

              
12345

            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

Fazemos o mesmo, mas especificamos prototype nos atributos. Isso garante que cada vez que injetarmos esse bean, será retornado um novo objeto.

Resumo

Neste capítulo sobre IoC (Inversão de Controle) e DI (Injeção de Dependência), foi explorado como o Spring gerencia a criação e o ciclo de vida dos beans por meio de seu container, possibilitando a injeção automática de dependências.

Foram discutidos o escopo padrão singleton, no qual uma única instância de um bean é reutilizada, e o escopo prototype, que cria uma nova instância para cada requisição, destacando como esses escopos impactam o gerenciamento de objetos e o design da aplicação.

1. O que é Inversion of Control (IoC) no Spring?

2. Qual princípio fundamenta a Dependency Injection (DI)?

question mark

O que é Inversion of Control (IoC) no Spring?

Select the correct answer

question mark

Qual princípio fundamenta a Dependency Injection (DI)?

Select the correct answer

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 2. Capítulo 4

Pergunte à IA

expand

Pergunte à IA

ChatGPT

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

What are some practical examples of using different bean scopes in a real application?

Can you explain the difference between @Component, @Service, @Repository, and @Controller in more detail?

How does Spring handle dependency injection with multiple constructors?

Awesome!

Completion rate improved to 3.45

bookIoC e DI

Deslize para mostrar o menu

O Spring Container é o componente central do Spring Framework responsável pela criação, configuração e ciclo de vida dos beans (objetos) dentro de uma aplicação. O Spring Container também é conhecido como IoC container.

Uma dependência refere-se a qualquer classe que exige que outros objetos sejam injetados para funcionar corretamente, e essa cadeia de dependências pode continuar indefinidamente. Normalmente, para criar um objeto com dependências, é necessário inicializá-lo explicitamente usando o operador new e especificar a classe.

É nesse ponto que o Spring atua com Inversion of Control e Dependency Injection. O conceito é que o Spring assume a responsabilidade de criar e gerenciar as dependências. Em vez de manualmente configurar a inicialização, basta anotar as classes necessárias, e o Spring as cria automaticamente e gerencia seu ciclo de vida dentro do seu contexto.

Uma dessas anotações é @Component, que deve ser colocada acima da classe.

BeanExample.java

BeanExample.java

copy

              
123

            
@Component
public class BeanExample {
}

Essa abordagem desloca o foco do gerenciamento manual de dependências, permitindo que desenvolvedores se concentrem na lógica de negócio enquanto o Spring lida com as tarefas de infraestrutura relacionadas à criação de objetos e ao gerenciamento de dependências.

Como o contêiner Spring funciona?

Quando a aplicação é iniciada, o Spring Container é inicializado. Ele começa escaneando as classes em busca de anotações como @Component, @Service, @Repository e @Configuration.

@Component é uma anotação geral que torna uma classe gerenciada pelo Spring, permitindo que ela seja registrada como um bean.

@Service, @Repository e @Controller são versões mais especializadas de @Component. Elas cumprem o mesmo propósito, mas indicam o papel específico da classe: @Service para lógica de negócio, @Repository para acesso a dados e @Controller para tratamento de requisições web.

@Configuration é utilizada para classes que contêm definições de beans e configuração da aplicação.

Ao marcar uma classe com uma dessas anotações, garante-se que ela se torne um bean dentro do contexto Spring.

Após a identificação das classes, o container procede à criação de instâncias dessas classes anotadas, transformando-as efetivamente em beans que o contexto do Spring gerencia ao longo do ciclo de vida da aplicação.

À medida que esses beans são criados, o container gerencia automaticamente suas dependências por meio da Injeção de Dependências. Esse processo permite que as classes recebam as dependências necessárias sem a necessidade de criá-las ou localizá-las explicitamente, otimizando o processo de desenvolvimento.

Injeção de Dependências (DI)

Primeiro, o Spring Container adiciona ao seu contexto os beans (classes) marcados com as anotações @Component, @Service, @Repository e @Configuration. Após isso, ele fornece esses beans para quaisquer objetos que os solicitarem.

Exemplo da Vida Real

Imagine o desenvolvimento de uma loja online. Existe uma classe OrderService que gerencia pedidos e uma classe PaymentService que processa pagamentos. Em vez de criar manualmente uma instância de PaymentService dentro de OrderService, é possível permitir que o Spring Container crie e injete PaymentService em OrderService.

OrderService.java

OrderService.java

PaymentService.java

PaymentService.java

copy

              
1234567891011121314

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Na classe OrderService, haverá um campo paymentService que é inicializado com o tipo exato necessário (PaymentService). Observe que não inicializamos explicitamente este objeto, o Spring fez isso por nós!

Se não tivéssemos anotado PaymentService com @Service, esse bean não teria sido adicionado ao contexto do Spring, e ocorreria um erro indicando que o Spring não encontrou tal bean.

@Autowired

Também é possível utilizar a anotação @Autowired, que instrui o Container do Spring a injetar o objeto apropriado no campo.

OrderService.java

OrderService.java

copy

              
123456789101112131415

            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

No Spring, a partir da versão 4.3, o uso da anotação @Autowired não é mais obrigatório ao injetar dependências por meio de um construtor se houver apenas um construtor na classe. O Spring determina automaticamente que este construtor deve ser utilizado para a injeção de dependências.

Quais são os Diferentes Tipos de Bean?

Imagine que você tem uma única máquina de café em uma cafeteria. Sempre que um cliente pede um café, o barista utiliza essa mesma máquina de café para preparar cada xícara. A máquina de café é sempre a mesma, não uma nova para cada pedido.

Da mesma forma, no Spring, quando você injeta um bean do contexto Spring, o Spring fornece sempre a mesma instância desse bean. Isso é conhecido como o escopo singleton. Assim como a máquina de café na cafeteria, o Spring garante que você sempre receba o mesmo objeto em vez de criar um novo a cada vez.

Singleton

Podemos definir o tipo utilizando a anotação @Scope e especificar singleton nos atributos.

SingletonService.

SingletonService.

copy

              
12345

            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService.java

PrototypeService.java

copy

              
12345

            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

Fazemos o mesmo, mas especificamos prototype nos atributos. Isso garante que cada vez que injetarmos esse bean, será retornado um novo objeto.

Resumo

Neste capítulo sobre IoC (Inversão de Controle) e DI (Injeção de Dependência), foi explorado como o Spring gerencia a criação e o ciclo de vida dos beans por meio de seu container, possibilitando a injeção automática de dependências.

Foram discutidos o escopo padrão singleton, no qual uma única instância de um bean é reutilizada, e o escopo prototype, que cria uma nova instância para cada requisição, destacando como esses escopos impactam o gerenciamento de objetos e o design da aplicação.

1. O que é Inversion of Control (IoC) no Spring?

2. Qual princípio fundamenta a Dependency Injection (DI)?

question mark

O que é Inversion of Control (IoC) no Spring?

Select the correct answer

question mark

Qual princípio fundamenta a Dependency Injection (DI)?

Select the correct answer

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 2. Capítulo 4
some-alt