java - with - Primavera: @Componente versus @Bean




what is autowired annotation in java (6)

  1. O @Component auto detecta e configura os beans usando a varredura do classpath, enquanto @Bean declara explicitamente um único bean, em vez de permitir que o Spring faça isso automaticamente.
  2. @Component não dissocia a declaração do bean da definição de classe, onde @Bean desacopla a declaração do bean da definição de classe.
  3. @Component é uma anotação de nível de classe onde @Bean é uma anotação de nível de método e o nome do método serve como o nome do bean.
  4. @Component não precisa ser usado com a anotação @Configuration onde a anotação @Bean deve ser usada dentro da classe que é anotada com @Configuration .
  5. Não podemos criar um bean de uma classe usando @Component, se a classe estiver fora do spring container, enquanto podemos criar um bean de uma classe usando @Bean, mesmo se a classe estiver presente fora do spring container .
  6. O @Component possui diferentes especializações como @Controller, @Repository e @Service, enquanto @Bean não possui especializações .

Eu entendo que a anotação @Component foi introduzida na primavera 2.5 para se livrar da definição do bean xml usando a varredura do caminho de classe.

@Bean foi introduzido na primavera 3.0 e pode ser usado com @Configuration para se livrar completamente do arquivo xml e usar a configuração java.

Teria sido possível reutilizar a anotação @Component vez de introduzir a anotação @Bean ? Meu entendimento é que o objetivo final é criar beans nos dois casos.


Ambas as abordagens visam registrar o tipo de destino no contêiner Spring.

A diferença é que @Bean é aplicável a métodos , enquanto @Component é aplicável a tipos .

Portanto, quando você usa a anotação @Bean controla a lógica de criação da instância no corpo do método (veja o exemplo acima ). Com a anotação @Component você não pode.


Vamos considerar que eu quero uma implementação específica, dependendo de algum estado dinâmico. @Bean é perfeito para esse caso.

@Bean
@Scope("prototype")
public SomeService someService() {
    switch (state) {
    case 1:
        return new Impl1();
    case 2:
        return new Impl2();
    case 3:
        return new Impl3();
    default:
        return new Impl();
    }
}

No entanto, não há como fazer isso com @Component .


Você tem duas maneiras de gerar beans. Uma @Component é criar uma classe com uma anotação @Component . A outra é criar um método e anotá-lo com @Bean . Para as classes que contêm o método com @Bean devem ser anotadas com @Configuration Depois de executar seu projeto de mola, a classe com uma anotação @ComponentScan examinaria cada classe com @Component e restauraria a instância dessa classe para o Ioc Container. Outra coisa que o @ComponentScan faria é executar os métodos com @Bean e restaurar o objeto de retorno para o Ioc Container como um bean. Então, quando você precisa decidir que tipo de beans você deseja criar, dependendo dos estados atuais, você precisa usar @Bean . Você pode escrever a lógica e retornar o objeto desejado. Outra coisa que vale a pena mencionar é o nome do método com @Bean é o nome padrão do bean.


@Component Preferível para varredura de componentes e fiação automática.

Quando você deve usar @Bean ?

Às vezes, a configuração automática não é uma opção. Quando? Vamos imaginar que você queira conectar componentes de bibliotecas de terceiros (você não tem o código-fonte para que não possa anotar suas classes com @Component), portanto, a configuração automática não é possível.

A anotação @Bean retorna um objeto que a mola deve registrar como bean no contexto do aplicativo. O corpo do método tem a lógica responsável por criar a instância.


@Component Esta é uma anotação genérica e pode ser aplicada a qualquer classe do aplicativo para torná-lo um componente gerenciado por mola (simplesmente, o estereótipo genérico para qualquer componente gerenciado por mola). quando o caminho de classe é varrido pelo recurso componente de varredura da primavera (@ComponentScan) , ele identificará as classes anotadas com a anotação @Component (dentro do pacote fornecido) e criará os beans de tais classes e as registrará no ApplicationContext. @Component é uma anotação de nível de classe e sua finalidade é tornar a classe como componente gerenciado por mola e bean auto-detectável para o recurso de varredura de classpath.

Se você quiser saber mais sobre o @Component e outras anotações de estereótipo, é recomendável consultar este artigo.

@Bean é usado para declarar e registrar explicitamente um bean (como um bean de configuração) no contêiner Spring IOC que é retornado de um método. @Bean é uma anotação de nível de método e é usada em uma classe que é anotada com @Configuration . Simplesmente, a anotação @Bean é usada para registrar o bean retornado por um método como um bean de configuração de mola no Contêiner IOC. @Bean é apenas uma anotação em nível de método e não pode ser usada com classes e declaração de objetos.

A anotação @Bean indica que um método produz um bean que deve ser gerenciado pelo contêiner Spring.

Para declarar um bean, basta anotar um método com a anotação @Bean . Quando o JavaConfig encontrar tal método, ele executará esse método e registrará o valor de retorno como um bean dentro de um ApplicationContext. Por padrão, o nome do bean será o mesmo que o nome do método. A seguir, um exemplo simples de uma declaração do método @Bean.

@Configuration
public class ApplicationConfig {

    @Bean
    public User adminUserProfile() {
        return new User("Rami","Nassar");
    }
}

Na classe ApplicationConfig, você pode ver que primeiro usamos a anotação @Configuration para informar ao Spring que esse é um arquivo de configuração baseado em Java. Depois, a anotação @Bean é usada para declarar um bean Spring e os requisitos de DI. A anotação @Bean é equivalente à tag, o nome do método é equivalente ao atributo id dentro do tag. Espero que, depois de ler este artigo, você tenha uma ideia clara sobre o real propósito e uso das anotações @Bean e @Component .





autowired