Printemps - utiliser des haricots d'usine en configuration?

Quelle est la façon correcte d'utiliser l'usine de haricots dans @Configuration classes?

Supposons que j'ai la suite pour SessionFactory:

@Bean
public AnnotationSessionFactoryBean sessionFactory() {
    AnnotationSessionFactoryBean factory = new AnnotationSessionFactoryBean();
    //set up properties etc.
    return factory;
}

Dès maintenant cette méthode retourne un haricot usine qui ne mettent pas en œuvre SessionFactory. Si je l'utilise dans un autre bean avec @Autowired comme SessionFactoryil fonctionne très bien et l'obtient, de la fève de l'usine:

@Controller
public class MyController {
    @Autowired SessionFactory sessionFactory;
    //...
}

Je suppose que c'est OK.

Cependant, cela devient un problème si je veux utiliser le SessionFactory dans la même classe de configuration:

@Bean
public HibernateTransactionManager transactionManager() {
    HibernateTransactionManager man = new HibernateTransactionManager();
    //Ideal - doesn't work because sessionFactory() return type doesn't match:
    //SessionFactory sessionFactory = sessionFactory();
    //Is this one correct?
    //SessionFactory sessionFactory = (SessionFactory) sessionFactory().getObject();
    man.setSessionFactory(sessionFactory);
    return man;
}

Quelle est La bonne Façon de mettre en œuvre ce type de dépendance?

source d'informationauteur Konrad Garus

20

@Configuration approche est relativement jeune et il a quelques aspérités. Usine de haricots sont l'un d'eux. Donc, il n'y a pas Droit Cheminau moins je ne suis pas au courant de tout. Peut-être l'avenir de Printemps, les sorties s'occupera de cette affaire en quelque sorte. Pour l'instant, c'est ma manière préférée:
```
@Bean
public AnnotationSessionFactoryBean sessionFactoryBean() {
    AnnotationSessionFactoryBean factory = new AnnotationSessionFactoryBean();
    //set up properties etc.
    return factory;
}

@Bean
public SessionFactory sessionFactory() {
   return (SessionFactory) sessionFactoryBean().getObject();
}
```
Et l'utilisation sessionFactory() méthode chaque fois que nécessaire. Si vous voulez appeler la sessionFactoryBean().getObject() plusieurs fois pour une raison quelconque (par exemple, lorsque FactoryBean ne retourne pas les singletons), n'oubliez pas d'utiliser @Scope annotation. Sinon, le Printemps assurez-vous que sessionFactory() est appelée qu'une seule fois et de mettre en cache le résultat.

Printemps est assez intelligent pour effectuer toutes initialisation requise après l'appel de @Bean méthode et avant de retourner le bean lui-même. Donc InitializingBeanDisposableBean@PostConstructetc. sont tous reconnus et traités correctement. En fait, j'ai toujours été de trouver l'appel de afterPropertiesSet un peu un hack, parce que c'est le conteneur de responsabilité.

Il y a aussi une deuxième méthode recommandée dans Le Printemps De La Banque De Données Du Document De Référence De La Documentationqui à première vue semble un peu incohérent, mais fonctionne très bien:
```
@Resource
private Mongo mongo;

@Bean
MongoFactoryBean mongo() {
     return new MongoFactoryBean();
}
```
Si l'usine est créée à l'aide de @Bean méthode, mais le haricot créé par l'usine peut être obtenue à l'aide de autocâblés champ. Intelligent.

J'ai trouvé un exemple sur la Printemps forums.

@Bean
public SessionFactory sessionFactory() {
    AnnotationSessionFactoryBean sessionFactoryBean = 
              new AnnotationSessionFactoryBean();
    //...configuration code here...
    sessionFactoryBean.afterPropertiesSet();
    return sessionFactoryBean.getObject();
}

Vous pouvez l'utiliser de la manière suivante:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class LoginServiceTest {

  @Configuration
  public static class Config {

    @Bean
    public HttpInvokerProxyFactoryBean loginServiceProxy() {
      HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();
      proxy.setServiceInterface(LoginService.class);
      proxy.setServiceUrl("http://localhost:8080/loginService");
      return proxy;
    }

  }

  @Inject
  private LoginService loginService;

  @Test
  public void testlogin() {
    loginService.login(...);
  }
}

Vous devez vous connecter pour publier un commentaire.