Obtenir une nouvelle instance du ressort de haricot

Garder le printemps fichier de configuration, beans.xml dans la racine du classpath.
Faire scope=prototype, se traduira par différentes instances de haricot pour chaque invocation de méthode getBean.

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="myinterface" class="MyImplClass" scope="prototype"/>
</beans>

Manière similaire, si vous voulez Printemps de retourner la même haricot exemple à chaque fois que l'on est nécessaire, vous devez déclarer le bean de la portée de l'attribut à singleton.

Une fois le conteneur IoC est initialisé, vous pouvez récupérer vos beans Spring. Mais assurez-vous que vous ne le dessous seulement d'initialisation qu'une seule fois.

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

Ensuite, vous pouvez changer votre code comme ci-dessous.

for (OtherClass obj : someList) {
MyInterface myInter = (MyInterface ) context.getBean("myinterface");
Thread t = new Thread(myInter);
t.start();
}

OriginalL'auteur Albin

La Première Note 1

Au lieu de créer et de départ fils par la main, je vous suggère d'utiliser un pool de threads que de l'extérieur configuré, de sorte que vous pouvez gérer le nombre de threads créés. Si la taille de someList est de 1000, en créant ainsi de nombreux threads est inefficace. Il est mieux d'utiliser un exécuteur testamentaire soutenu par un pool de threads. Spring fournit des implémentations qui peut être utilisé comme beans spring configuré avec le task espace de noms, quelque chose comme ceci:

<task:executor id="executor" queue-capacity="10" rejection-policy="CALLER_RUNS" />

queue-capacity est la taille maximale du pool de threads. Si cette taille est dépassée, le thread courant sera exécuter la tâche supplémentaire, bloquant ainsi la boucle jusqu'à ce qu'un autre thread est libéré (rejection-policy="CALLER_RUNS"). Voir la task:executor de la documentation, ou de définir toute ThreadPoolExecutor (printemps ou jdk-simultanées) avec votre propre configuration.

La Première Note 2

Si le seul état que vous l'intention de le stocker dans MyClassImpl est l'élément de la liste, vous pouvez oublier le reste de l'explication ci-dessous (sauf pour le pool de threads trucs), et d'utiliser directement un singleton bean : supprimer le Runnable de l'interface et de ses non-arg run() méthode, ajouter un run(OtherClass obj) méthode et de faire quelque chose comme ceci:

final MyInterface task = //get it from spring as a singleton
for (final OtherClass obj : someList) {
  executor.execute(new Runnable() {
    public void run() {task.run(obj);}
  });
  //jdk 8 : executor.execute(task::run);
}

Si vous prévoyez de stocker de l'état à l'intérieur MyClassImpl lors de l'exécution de run() (autres que les traités de l'objet), aller sur la lecture. Mais vous pourrez toujours utiliser le run(OtherClass obj) méthode au lieu de n-args run().

L'idée de base est d'obtenir un objet différent pour chaque thread en cours d'exécution, basée sur une sorte de modèle ou prototype défini comme un printemps bean. Afin de réaliser cela, il suffit de définir le haricot que vous voulez d'abord passer à chaque thread comme un proxy qui distribue à une instance qui est lié à la thread en cours d'exécution. Cela signifie que la même instance de la tâche est injecté dans chaque thread, et au cours de l'exécution du thread, la véritable tâche sur laquelle vous appelez des méthodes est lié au thread courant.

Programme principal

Puisque vous êtes en utilisant les éléments de la liste à faire de votre entreprise, vous passerez chaque élément à son propriétaire de la tâche.

public class Program {
  @Resource private MyInterface task; //this is a proxy
  @Resource private TaskExecutor executor;

  public void executeConcurrently(List<OtherClass> someList) {
    for (final OtherClass obj : someList) {
      executor.execute(new Runnable() {
        public void run() { task.run(obj); }
      });
      //jdk 8 : executor.execute(task::run);
    }
  }
}

Nous supposons que Program est un ressort de haricots, ainsi que les dépendances peuvent être injectées. Si Program n'est pas un printemps bean, vous aurez besoin d'obtenir le printemps ApplicationContext de quelque part, alors autowire Program (c'est à dire injecter des dépendances trouvé dans l'ApplicationContext, basé sur les annotations). Quelque chose comme ceci (dans le constructeur) :

public Program(ApplicationContext ctx) {
  ctx.getAutowireCapableBeanFactory().autowireBean(this);
}

Définir la tâche

<bean id="taskTarget" class="MyImplClass" scope="prototype" autowire-candidate="false" />

<bean id="task" class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="targetSource">
    <bean class="org.springframework.aop.target.ThreadLocalTargetSource">
      <property name="targetBeanName" value="taskTarget"/>
      <property name="targetClass" value="MyInterface"/>
    </bean>
  </property>
</bean>

taskTarget est là que vous définissez dans votre entreprise. Ce bean est défini comme un prototype, comme une nouvelle instance sera attribuée à chaque thread. Grâce à cela, vous pouvez même stocker l'état qui dépend de la run() paramètre. Ce bean est jamais utilisé directement par l'application (donc autowire-candidate="false"), mais il est utilisé à travers le task bean. Dans executeConcurrently() ci-dessus, la ligne task.run(obj) sera effectivement distribué sur l'un des prototype taskTarget qui a été créé par le proxy.

OriginalL'auteur Gaetan

D'abord et avant tout, nous savons tous que, par défaut, printemps conteneur créer bean dans le singleton mode (si vous n'avez pas spécifier explicitement le champ d'application). Comme son nom l'indique, singleton garantie que chaque fois que vous appelez le haricot, il vous donnera la même instance. Néanmoins, il y a peu de différences entre singleton au printemps avec l'un singleton que mentionné par le GoF. Au Printemps, l'instance créée sera limité au conteneur (pas de JVM que nous avons trouvé dans le GoF).

En outre, au printemps, vous pouvez définir deux bean instances du même type mais avec des noms différents et ils seront deux instances différentes créé sur le tas. Mais à chaque fois que vous faites référence à l'un de ces grains par le nom (ref= dans un haricot définition ou getBean sur le appContext), vous obtenez le même objet à chaque fois. C'est évidemment différente de l'pattern singleton, mais similaire dans le concept de toute façon.

Généralement parlant, il y a des implications de l'utilisation d'un singleton dans une application multi-thread (Printemps singleton ou réelle singleton). Tout état qui vous garder sur ces objets doivent tenir compte du fait que plusieurs threads. Généralement, tout état qui existe sera défini lors de l'instanciation par l'intermédiaire d'un setter ou argument du constructeur. Cette catégorie de Printemps bean a de sens pour longue durée de vie des objets, thread-safe objets. Si vous voulez quelque chose de thread spécifique et toujours envie de printemps pour créer l'objet, puis prototype champ d'application les œuvres.

OriginalL'auteur MCHAppy