Printemps: comment instancier un Printemps bean qui prend un paramètre d'exécution?

J'ai un singleton Printemps bean qui crée un couple de tâches (java.util.concurrent.Callable's) lors de l'exécution pour faire son travail en parallèle. Maintenant, la Callables'sont définis comme les classes internes dans le singleton bean, et le singleton bean crée, tout simplement, par l'instanciation avec new Task(in), où in est un paramètre connu qu'à l'exécution.

Maintenant je veux extraire l'intérieure de la Tâche de la classe à un habitué de haut-niveau de la classe parce que je veux rendre la Tâche du call() méthode transactionnelle, donc j'ai besoin d'elle pour être une source de haricot.

Je suppose que j'ai besoin de donner mon singleton une sorte d'usine de Tasks, mais les tâches doivent être prototype de beans Spring, qui prend une valeur d'exécution comme un paramètre de constructeur. Comment puis-je y arriver?

ce n'est pas une question sur le test des applications multi-thread, c'est une question à propos de Printemps. En fait, je vais supprimer raison n ° 2 de ma question, car elle détourne l'attention du véritable problème.
Voir: stackoverflow.com/questions/8772585/...
ok j'ai supprimé mon commentaire, btw, je pense que le plus simple est de créer des services de haricots, de décorer leurs méthodes transactionnelles, de les injecter à votre singleton et passe "dans" paramètre des méthodes de service.

OriginalL'auteur Jan Van den bosch | 2012-02-24

2

De printemps de la fève à l'usine et les nouvelles sont mutuellement exclusifs. Vous ne pouvez pas appeler de nouveau et s'attendre à ce que l'objet soit en vertu du Printemps de contrôle.

Ma suggestion est d'injecter de ces Tâches dans le Singleton. Faire beans Spring, trop.

Vous devez reconnaître que la Tâche elle-même ne va pas être de la transaction, mais ses dépendances. Injecter dans les Tâches et laissez Printemps gérer les transactions.

+1 pour la BAISER. Pas de raison de rendre les choses plus difficiles qu'ils doivent être, il suffit de créer des services transactionnels et de les injecter dans les tâches.
"Le printemps de la fève de l'usine et de nouvelles sont mutuellement exclusifs." Il peut sembler évident pour la plupart, mais pour un printemps débutant c'est très important pour moi d'entendre. Il m'a aidé à comprendre ce que le printemps ne fait.
Mais que faire Si je ne sais pas le nombre de tâches? I. e. quelqu'un soumet une tâche avec un certain nombre, disons, 10, et j'instancie 10 tâches? Pourriez-vous nous dire comment injecter des Tâches en Singleton dans de tels cas?
Vous devez créer un pool de Exécuteurs testamentaires et les laisser gérer vos tâches. Oublier Singleton et d'apprendre de Printemps.

OriginalL'auteur duffymo

Une autre approche pourrait être d'utiliser le Printemps @Configurable annotation avec les temps de charge de tissage, de cette façon, vous pouvez utiliser new (au lieu d'un bean factory) pour créer filaire Exigible au moment de l'exécution:

@Configurable
public class WiredTask implements Callable<Result> {

    @Autowired
    private TaskExecutor executor;

    public WiredTask(String in) {
        this.in = in;
    }

    public Result call() {
        return executor.run(in);
    }
}

@Bean @Scope("prototype")
public class TaskExecutor() {

    @Transactional
    public Result run(String in) {
        ...
    }
}

//Example of how you might then use it in your singleton...
ExecutorService pool = Executors.newFixedThreadPool(3);
WiredTask task = new WiredTask("payload");
Future<Result> result = pool.submit(task);

Voir cet article pour plus d'info. Remarque vous ne pouvez pas utiliser @Configurable et @Transactionnelle dans le même bean, d'où la nécessité pour les deux classes. Pour cette raison, ce ne serait pas la solution idéale si vous avez beaucoup de différentes implémentations de Callable (puisque vous aurez besoin de 2 classes pour chacune).

OriginalL'auteur seanhodges

Votre singleton haricot peut mettre en œuvre BeanFactoryAware et de recherche de grains de l'contenant de l'usine de ressorts.

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class MyBeanFactory implements BeanFactoryAware {

    private BeanFactory beanFactory;

    public void setBeanFactory(BeanFactory beanFactory) 
            throws BeansException    {
        this.beanFactory = beanFactory;     
    }

    public Task createTask(Task in) {
        return beanFactory.getBean("task",in);
    }

}
///////////////

import java.util.concurrent.Callable;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Scope;
import org.springframework.transaction.annotation.Transactional;

@Configurable //unless using xml based config
@Scope(value="prototype") //tell bean factory to create new instance each time
public class Task implements Callable<Object> {

    private Object in;

    public Task(Object in) {
        super();
        this.in = in;
    }

    @Transactional
    public Object call() throws Exception {
        //do real work
        return in;
    }   
}
///

OriginalL'auteur sw1nn

Vous devez vous connecter pour publier un commentaire.