O que no mundo são os grãos de primavera?

Ainda estou para encontrar uma definição de alto nível de beans Spring que eu possa entender. Eu os vejo referenciados frequentemente na documentação e livros do Grails, mas acho que entender o que são seria benéfico. Então, o que são grãos de primavera? Como eles podem ser usados? Eles têm algo a ver com injeção de dependência?

Os objetos que formam a espinha dorsal do seu aplicativo e 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. Esses beans são criados com os metadados de configuração que você fornece ao contêiner, por exemplo, na forma de <bean/>definições XML .

Mais para aprender sobre beans e escopo no SpringSource :

Quando você cria uma definição de bean, o que realmente está criando é uma receita para criar instâncias reais da classe definida por essa definição de bean. A ideia de que uma definição de bean é uma receita é importante, pois significa que, assim como uma classe, é possível ter muitas instâncias de objetos criadas a partir de uma única receita.

Você pode controlar não apenas as várias dependências e valores de configuração que devem ser conectados a um objeto criado a partir de uma definição de bean específica, mas também o escopo dos objetos criados a partir de uma definição de bean específica. Essa abordagem é muito poderosa e oferece a flexibilidade de escolher o escopo dos objetos que você cria através da configuração, em vez de ter que 'incorporar' o escopo de um objeto no nível da classe Java. Os beans podem ser definidos para serem implementados em um de vários escopos

* IoC: Inversão de Controle

Spring beans são apenas objetos de instância que são gerenciados pelo contêiner Spring, ou seja, são criados e conectados pela estrutura e colocados em um "pacote de objetos" (o contêiner) de onde você pode obtê-los posteriormente.

A parte "cablagem" é sobre o que é a injeção de dependência, o que significa é que você pode simplesmente dizer "Vou precisar disso" e a estrutura seguirá algumas regras para obter a instância correta.

Para alguém que não está acostumado ao Spring, acho que o artigo do Wikipedia Spring tem uma boa descrição :

O ponto central do Spring Framework é a inversão do contêiner de controle, que fornece um meio consistente de configurar e gerenciar objetos Java usando reflexão. O contêiner é responsável por gerenciar os ciclos de vida de objetos específicos: criando esses objetos, chamando seus métodos de inicialização e configurando esses objetos conectando-os.

Objetos criados pelo contêiner também são chamados de objetos gerenciados ou beans . O contêiner pode ser configurado carregando arquivos XML ou detectando anotações Java específicas em classes de configuração. Essas fontes de dados contêm as definições de bean que fornecem as informações necessárias para criar os beans.

Os objetos podem ser obtidos por meio de pesquisa de dependência ou injeção de dependência . A pesquisa de dependência é um padrão em que um chamador solicita ao objeto contêiner um objeto com um nome específico ou de um tipo específico. Injeção de dependência é um padrão em que o contêiner passa objetos por nome para outros objetos, por meio de construtores, propriedades ou métodos de fábrica.

Primeiro vamos entender a primavera:

A primavera é uma estrutura leve e flexível.

Analogia:

Bean: é um objeto criado, gerenciado e destruído no Spring Container. Podemos injetar um objeto no Spring Container por meio dos metadados (xml ou anotação), chamados inversão de controle.

Analogia: Vamos supor que o agricultor tenha uma terra cultivada por sementes (ou grãos). Aqui, o agricultor é o Spring Framework, as terras agrícolas são o Spring Container, o feijão é o Spring Bean, o cultivo é o Spring Processors.

Como o ciclo de vida do feijão, o feijão também possui seu próprio ciclo de vida.

fonte img

A seguir, é apresentada a sequência de um ciclo de vida do bean no Spring:

• Instanciar: primeiro, o contêiner de primavera localiza a definição do bean no arquivo XML e instancia o bean.

• Preencher propriedades: Usando a injeção de dependência, o spring preenche todas as propriedades conforme especificado na definição de bean.

• Definir nome do bean: se o bean implementa a BeanNameAwareinterface, a primavera passa o ID do bean para o setBeanName()método

• Definir fábrica de Bean: Se o Bean implementa a BeanFactoryAwareinterface, o spring passa a beanfactory para o setBeanFactory()método

• Pré-inicialização: Também chamado de pós-processo do bean. Se houver algum Bean BeanPrProcessors associado ao bean, o Spring chamará o postProcesserBeforeInitialization()método.

• Inicializar beans: se o bean implementar IntializingBean, seu afterPropertySet()método será chamado. Se o bean tiver a declaração do método init, o método de inicialização especificado será chamado.

• Pós-inicialização: - Se houver algum BeanPostProcessorsassociado ao bean, seus postProcessAfterInitialization()métodos serão chamados.

• Pronto para uso: agora o bean está pronto para uso pelo aplicativo

• Destruir: se o bean implementar DisposableBean, ele chamará o destroy()método

Bem, você entendeu parcialmente. Você deve adaptar os grãos de acordo com sua necessidade e informar o contêiner do Spring para gerenciá-lo quando necessário, usando uma metodologia conhecida popularmente como IoC ( Inversion of Control ) criada por Martin Fowler , também conhecida como Dependency Injection (DI).

Você conecta os beans de uma maneira, para que não precise cuidar da instanciação ou avaliar qualquer dependência do bean. Isso é conhecido popularmente como Princípio de Hollywood .

O Google é a melhor ferramenta para explorar mais sobre isso, além dos links com os quais você seria inundado aqui nesta pergunta. :)

A primavera possui o contêiner de IoC que carrega o saco de feijão; manutenção de criação e exclusão são de responsabilidade do Spring Container. Podemos colocar o feijão no Spring por cablagem e cablagem automática. Ligação significa que configuramos manualmente no arquivo XML e "Ligação automática" significa que colocamos as anotações no arquivo Java e o Spring verifica automaticamente o contexto raiz onde o arquivo de configuração java, cria e coloca no saco do Spring.

Aqui está o URI detalhado em que você obteve mais informações sobre o Beans

Spring beans são classes. Em vez de instanciar uma classe (usando new), você obtém uma instância como uma beanconversão para o seu tipo de classe no contexto do aplicativo, em que o bean é o que você configurou na configuração do contexto do aplicativo. Dessa forma, o aplicativo inteiro mantém uma instância de escopo único em todo o aplicativo. Todos os beans são inicializados seguindo sua ordem de configuração logo após o contexto do aplicativo ser instanciado. Mesmo que você não obtenha nenhum bean em seu aplicativo, todas as instâncias de beans já serão criadas no momento seguinte à criação do contexto do aplicativo.

• Spring beans são apenas instâncias de objetos gerenciadas pelo contêiner Spring IOC.

• O contêiner Spring IOC carrega o saco de feijão. A criação, manutenção e exclusão do feijão são de responsabilidade do Spring Container.

• Podemos colocar o feijão no Spring por cablagem e cablagem automática.

• Fiação significa que nós o configuramos manualmente no arquivo XML.

• Fiação automática significa que colocamos as anotações no arquivo Java e o Spring verifica automaticamente o contexto raiz onde o arquivo de configuração java, cria e coloca no saco do Spring.

Um Bean é um POJO (Plain Old Java Object), que é gerenciado pelo contêiner de primavera.

Os contêineres Spring criam apenas uma instância do bean por padrão. Esse bean é armazenado em cache na memória para que todas as solicitações para o bean retornem uma referência compartilhada para o mesmo bean.

A anotação @Bean retorna um objeto que registra a primavera como um bean no contexto do aplicativo. A lógica dentro do método é responsável por criar a instância.

Quando usamos a anotação @Bean?

Quando a configuração automática não é uma opção. Por exemplo, quando queremos conectar componentes de uma biblioteca de terceiros, porque o código fonte não está disponível, não podemos anotar as classes com @Component.

Um cenário em tempo real pode ser que alguém queira se conectar ao bucket do Amazon S3. Como a fonte não está disponível, ele teria que criar um @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Origem do código acima -> https://www.devglan.com/spring-mvc/aws-s3-java

Porque mencionei a anotação @Component acima.

@Component Indica que uma classe anotada é um "componente". Essas classes são consideradas candidatas à detecção automática ao usar a configuração baseada em anotação e a verificação do caminho da classe.

A anotação de componente registra a classe como um único bean.

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

Para a primavera, todos os objetos são feijões! A etapa fundamental no Spring Framework é definir seus objetos como beans. Beans nada mais são do que instâncias de objetos que seriam criadas pela estrutura spring observando suas definições de classe. Essas definições basicamente formam os metadados de configuração. A estrutura cria um plano para o qual os objetos precisam ser instanciados, quais dependências precisam ser definidas e injetadas, o escopo da instância recém-criada etc., com base nesses metadados de configuração.

Os metadados podem ser fornecidos em um arquivo XML simples, como no primeiro capítulo. Como alternativa, é possível fornecer os metadados como Anotação ou Configuração Java.

Livro: Just Spring

A configuração XML do Spring é composta de Beans e Beans são basicamente classes. Eles são apenas POJOs que usamos dentro do nosso ApplicationContext. A definição de Beans pode ser considerada uma substituição da palavra-chave new. Portanto, onde quer que você esteja usando a palavra-chave new em seu aplicativo, algo como:

MyRepository myRepository =new MyRepository ();

Onde você está usando essa palavra-chave new em algum lugar, pode remover a configuração e colocá-la em um arquivo XML. Então, codificaremos assim:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Agora podemos simplesmente usar a injeção de setter / injeção de construtor. Estou usando a injeção de setter.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}