O que é um Spring Bean?

1. Visão geral

Bean é um conceito-chave do Spring Framework. Como tal, é essencial entender essa noção para entender o quadro e usá-lo de maneira eficaz.

Infelizmente,there aren’t clear answers to a simple question – what a Spring bean really is. Algumas explicações chegam a um nível tão baixo que uma imagem grande é perdida, enquanto outras são muito vagas.

Este tutorial tentará esclarecer o assunto, começando com uma descrição na documentação oficial.

Leitura adicional:

Por que escolher o Spring como seu Java Framework?

Uma visão geral rápida e prática da principal proposição de valor do framework Spring.

Noções básicas sobre getBean () no Spring

Aprenda sobre as diferentes variantes do método BeanFactory.getBean () do Spring para recuperar uma instância de bean do contêiner Spring

2. Definição de Feijão

Aqui está uma definição de feijão emthe Spring Framework documentation:

No Spring, os objetos que formam o backbone de seu aplicativo e que são gerenciados pelo contêiner Spring IoC são chamados de beans. Um bean é um objeto que é instanciado, montado e gerenciado por um contêiner Spring IoC.

Esta definição é concisa e vai direto ao ponto,but misses an important thing – Spring IoC container. Vamos descer pela toca do coelho para ver o que é e os benefícios que traz.

3. Inversão de controle

Simplificando,Ihttps: //www.example.com/inversion-control-and-dependency-injection-in-spring [nversion of Control], ou IoC para breve, éa process in which an object defines its dependencies without creating them. Este objeto delega o trabalho de construir tais dependências para um contêiner IoC.

Vamos começar com a declaração de algumas classes de domínio antes de mergulhar no IoC.

3.1. Classes de domínio

Suponha que tenhamos uma declaração de classe:

public class Company {
    private Address address;

    public Company(Address address) {
        this.address = address;
    }

    // getter, setter and other properties
}

Esta classe precisa de um colaborador do tipoAddress:

public class Address {
    private String street;
    private int number;

    public Address(String street, int number) {
        this.street = street;
        this.number = number;
    }

    // getters and setters
}

3.2. Abordagem tradicional

Normalmente, criamos objetos com os construtores de suas classes:

Address address = new Address("High Street", 1000);
Company company = new Company(address);

Não há nada de errado com essa abordagem, mas não seria bom gerenciar as dependências de uma maneira melhor?

Imagine um aplicativo com dezenas ou mesmo centenas de classes. Às vezes, queremos compartilhar uma única instância de uma classe em todo o aplicativo, outras vezes, precisamos de um objeto separado para cada caso de uso e assim por diante.

Gerenciar um número tão grande de objetos é um pesadelo. This is where Inversion of Control comes to the rescue.

Em vez de construir dependências por si só, um objeto pode recuperar suas dependências de um contêiner de IoC. All we need to do is to provide the container with appropriate configuration metadata.

3.3. Configuração do Bean

Primeiro, vamos decorar a classeCompany com a anotação@Component:

@Component
public class Company {
    // this body is the same as before
}

Esta é uma classe de configuração que fornece metadados de bean a um contêiner IoC:

@Configuration
@ComponentScan(basePackageClasses = Company.class)
public class Config {
    @Bean
    public Address getAddress() {
        return new Address("High Street", 1000);
    }
}

A classe de configuração produz um bean do tipoAddress. Ele também carrega a anotação@ComponentScan, que instrui o contêiner a procurar por beans no pacote que contém a classeCompany.

Quando um contêiner Spring IoC constrói objetos desses tipos, todos os objetos são chamados de beans Spring, pois são gerenciados pelo contêiner IoC.

3.4. IoC em ação

Já que definimos beans em uma classe de configuração,we’ll need an instance of the AnnotationConfigApplicationContext class to build up a container:

ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

Um teste rápido verifica a existência e os valores de propriedade de nossos beans:

Company company = context.getBean("company", Company.class);
assertEquals("High Street", company.getAddress().getStreet());
assertEquals(1000, company.getAddress().getNumber());

O resultado prova que o contêiner de IoC criou e inicializou os beans corretamente.

4. Conclusão

Este tutorial forneceu uma breve descrição dos beans Spring e seu relacionamento com um contêiner de IoC.

O código-fonte completo deste tutorial pode ser encontradoover on GitHub.

TOC

O que é um Spring Bean?