Quelle devrait être la méthode principale de Java pour une application autonome (pour Spring JMS)?

Question

Je suis intéressé par la création d'une application Spring autonome qui s'exécutera et attendra de recevoir des messages d'une file d'attente ActiveMQ en utilisant Spring JMS. J'ai cherché beaucoup d'endroits et ne peux pas trouver une manière consistante de mettre en application la méthode principale pour une telle application autonome. Il semble y avoir peu d'exemples d'applications autonomes Spring. J'ai regardé Tomcat, JBoss, ActiveMQ et d'autres exemples du monde entier mais je ne suis pas arrivé à une conclusion donc ...

Quelle est la meilleure pratique pour implémenter une méthode principale pour une application Java (spécifiquement printemps avec JMS)?

Mise à jour: Voici un exemple de: http://forum.springsource.org/showthread.php?t=48197 Est-ce la meilleure façon de le faire?

public static void main(String args[]) { 
     try { 
      ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); 
      . . . . . 
      Object lock = new Object(); 
      synchronized (lock) { 
       lock.wait(); 
      } 

     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
} 

Answer 1

Tentative de lecture dans une boucle. Si un message est trouvé, traitez-le, puis dormez et recommencez. Mettez également une sorte de logique de terminaison dedans (interrompez le fil). Vous pouvez terminer après les tentatives de X, lues à partir d'un fichier, tuer la machine virtuelle Java, lire une terminaison msg de la file d'attente, etc., etc.

public static void main(String[] args) { 
    while(true) { 
     // look for some terminator 
     // attempt to read off queue 
     // process message 
     try { 
      TimeUnit.SECONDS.sleep(5); 
     } catch (Exception e) { 
      break; 
     } 
    } 
} 

Answer 2

Dans votre main() faire quelque chose comme ceci:

// gather config files 
String[] configs = { "classpath:applicationContext-myutil.xml" }; 

// create the app context 
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(configs); 

// obtain reference to your utility bean 
MyUtilityBean utility = (MyUtilityBean) ctx.getBean("utility"); 

// invoke methods on your utility bean 
utility.doSomething() 

Vous devez injecter votre bean Utiltity avec Spring's JMS template pour faire le gruntwork pour votre utilisation.

Answer 3

C'est ce que nous avons, à l'intérieur app-context.xml nous utilisons des classes JMS de printemps comme (org.springframework.jms.listener.DefaultMessageListenerContainer pour gérer nombre de consommateurs et de fournir l'auditeur personnalisé à l'aide org.springframework.jms .application.adapter.MessageListenerAdapter)

app-context.xml contient tous les écouteurs de beans de printemps et d'autres choses, le code ci-dessous est bootstrapping Spring fourni écouteurs sur les files d'attente. Donc, l'idée est d'utiliser des classes de printemps pour gérer plusieurs consommateurs. Faites-moi savoir si c'est ce dont vous avez besoin et si vous avez besoin de plus d'informations sur la configuration de MessageListenerAdapter.

public static void main(String[] args) 
{ 

    try 
    { 
     new ClassPathXmlApplicationContext("app-context.xml"); 

    } 
    catch (Throwable e) 
    { 
     e.printStackTrace(); 
     System.exit(-1); 
    } 

} 

Answer 4

L'idée principale est de faire attendre le thread principal jusqu'à ce que l'application soit terminée. while (terminé!) Est la bonne façon d'attendre que le thread principal se réveille. FinishEventHandler - est une méthode qui gère l'événement finish/quit. Je considère que l'initialisation JMS est faite dans Spring conf. et en ". . . . ." section.

public static void main(String args[]) { 

try { 
     ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); 
     lock = new Object(); 

     while(!finished) { 
      synchronized (lock) { 
       lock.wait(); 
      } 
     } 

    } catch (Exception e) { 
     e.printStackTrace(); 
    } 

}

public void finishEventHandler() { 
    finished = true; 
    lock.notify(); 
} 

Answer 5

Lorsque vous utilisez JMS Spring vous utilisez déjà des composants/haricots dans votre configuration qui obtiennent automatiquement démarré et vont rester en vie (abonnez-vous et lire la file d'attente/sujet) jusqu'à ce que vous arrêtez la application.

Pour démarrer et maintenir l'exécution de l'application, le chargement du contexte d'application devrait donc être suffisant. Une bonne pratique consiste à appeler également le registerShutdownHook, donc sur un arrêt de l'application (i.e via ctrl + c dans la console), al vos haricots sont gracieusement arrêt et disposés :)

public static void main(String args[]) { 
    AbstractApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); 
    context.registerShutdownHook(); 
}