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

398

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?

grantmcconnaughey
fonte
2
Grails é construído na primavera. Se você não conhece o Spring, sugiro que você leia pelo menos algum material para entender as tecnologias que está usando.
perfil completo de Jeff Storey
26
Acho que os comentários aqui sofrem com o mesmo problema que o OP vê nas referências nos documentos e livros do Grails: eles são fáceis apenas para pessoas que já sabem o que querem dizer. Acho que o artigo da Wikipedia descreve muito melhor para um iniciante.
Elias Dorneles
12
@MarcoForberg, uma das razões pelas quais a versão antiga do Spring é o principal sucesso no Google, porque as pessoas continuam vinculando-a a partir de lugares como SO ... static.springsource.org/spring/docs/3.2.x/… seria melhor lugar para começar nos dias de hoje.
11263 Ian Roberts
5
+1 em @IanRoberts. Aqui está o atual .
dmahapatro
Não ajuda que eles introduzam a IoC dizendo que a IoC também é conhecida como DI. Eles estão relacionados sim, mas a IoC é muito mais ampla.
Aluan Haddad

Respostas:

212

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

Juned Ahsan
fonte
10
Portanto, esses são objetos que o contêiner gerencia e eu não preciso tocar, mas se eu quiser acessar um bean para talvez chamar alguns métodos ou recuperar propriedades, posso "pedir" Spring para o bean?
grantmcconnaughey
22
@grantmc É mais ou menos assim, exceto que a inversão do controle deve ser entendida como o contrário de "ask": em vez de "pedir" coisas, você "declara" que precisará. E então, quando você inicia o aplicativo, a estrutura verifica todas as declarações e define a instância apropriada.
Elias Dorneles
6
@elias Como declaro que preciso? É quando estou usando @Autowired? Ou simplesmente quando eu faço meus imports?
Mikhail Batcer
16
Seria útil definir o que a IoC significa para os recém-chegados do Spring.
23416 Lucas Lucas
4
@lucas concordou. IoC é "Inversão de controle". Veja excelentes perguntas e respostas: O que é injeção de dependência e inversão de controle no Spring Framework? e o que é inversão de controle? .
Mhradek
135

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.

Elias Dorneles
fonte
Uma instância é apenas outra palavra para objetos. Quando você usa "instâncias de objetos", não está dizendo objetos?
Chama de udun
Pergunta interessante. De acordo com a Wikipedia, devo dizer "objetos de instância": en.wikipedia.org/wiki/Instance_(computer_science)
Elias Dorneles 5/18
2
A toca do coelho vai mais fundo.
Flame of udun
Hoje percebi que "objetos objetos" (e, portanto, instâncias de objetos) realmente fazem sentido para mim, porque estou acostumado a linguagens em que uma classe também é um objeto (para que você tenha objetos de classe e, bem, objetos "objetos" ) De qualquer forma, atualizei a descrição para usar "objetos de instância", conforme o artigo da Wikipedia. ^^
Elias Dorneles
11
@Ruizhi um objeto regular, ou seja, uma instância de uma classe - essa discussão foi um desvio sobre o uso da expressão correta para se referir a um objeto. :)
Elias Dorneles
50

Primeiro vamos entender a primavera:

A primavera é uma estrutura leve e flexível.

Analogia:
insira a descrição da imagem aqui

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.

insira a descrição da imagem aqui

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

insira a descrição da imagem aqui

insira a descrição da imagem aqui

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

Premraj
fonte
23

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. :)

dmahapatro
fonte
2
Não é possível apontar que IoC é o conceito e DI é (uma das) técnicas que podem ser usadas para obter IoC; elas não são definições substituíveis.
kekko12
9

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

Yasir Shabbir Choudhary
fonte
8

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.

Downhillski
fonte
11
Beans não são classes, mas objetos como instâncias de classes, gerenciadas por uma implementação de contêiner.
Chatatata 01/01/19
7
  • 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.

maniBrock
fonte
7

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.

IonKat
fonte
2

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;

user3472473
fonte
1

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

BERGUIGA Mohamed Amine
fonte
1

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();
    }
}
Muhammad Waqas Dilawar
fonte