JMS est la réponse à la nécessité d'une file d'attente de blocage persistant?

Question

Je crée une bibliothèque qui se compose d'un appender Log4J qui envoie de manière asynchrone des événements à un serveur distant. Lorsqu'une instruction de journal est fait, le appender enregistrera l'événement de manière asynchrone dans une file d'attente locale d'un pool de consommateurs sera ensuite récupérer et envoyer à la télécommande.

La solution complètement en mémoire serait de créer une BlockingQueue qui traiterait la question de la concurrence. Cependant, je voudrais que la file d'attente d'être persisté de telle sorte que si le serveur distant n'est pas disponible Je ne cultivons pas la file d'attente ou sans borne commence à suppression des messages dans le cas d'une file d'attente bornée.

Je pensais à l'aide d'une base de données H2 intégré pour stocker les événements localement, puis utiliser un mécanisme d'interrogation pour récupérer des événements et envoyer à la télécommande. J'utiliserais bien plutôt que de BlockingQueue interroger une table de base de données.

est la réponse JMS?

EDIT:

Si JMS est la réponse, et il semble aller de cette façon, quelqu'un at-il des recommandations sur un poids léger, solution JMS intégrable qui peut être configuré pour accepter uniquement les messages en cours de traitement? En d'autres termes, je ne veux pas, et peut-être ne sera pas autorisé à, ouvrir une socket TCP sur lequel écouter.

EDIT:

J'ai ActiveMQ intégré maintenant et il semble fonctionner. Merci à tous.

Answer 1

Vous pouvez utiliser JMS à des messages de manière asynchrone envoyer à une machine distante (en supposant qu'il peut les recevoir bien sûr), Log4j a une Appender JMS vous pouvez utiliser pour cela.

Answer 2

Bob Lee en open source un disque très simple file d'attente soutenu un certain temps, https://github.com/square/retrofit/blob/master/modules/android/src/retrofit/io/QueueFile.java - peut être utile, et est certainement beaucoup plus facile d'introduire que JMS si vous pouvez accepter la durabilité locale.

Cette classe est autonome -. Il peut être copié et collé

Answer 3

Vous pouvez certainement utiliser JMS à cette fin. Pour autant que je comprends que vous utilisez le appender JMS Log4J. Ce composant envoie des messages à destination pré-configuré JMS (typiquement file d'attente). Vous pouvez configurer cette file d'attente pour être persisté. Dans ce cas, tous les messages insérés dans la file d'attente seront automatiquement stockées dans un certain magasin persistant (généralement de base de données.). Malheureusement, cette configuration est spécifique du fournisseur (dépend du fournisseur JMS), mais est généralement très simple. S'il vous plaît se référer à la documentation de votre fournisseur JMS.

Answer 4

Voir si cela fonctionne

Ce code devrait fonctionner pour vous - son d'une file d'attente dans le blocage persistant de la mémoire - a besoin d'un accord de fichier, mais devrait fonctionner

       package test;

     import java.io.BufferedReader;
     import java.io.BufferedWriter;
     import java.io.File;
     import java.io.FileReader;
     import java.io.FileWriter;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.Collections;
     import java.util.LinkedList;
     import java.util.List;

     public class BlockingQueue {

    //private static Long maxInMenorySize = 1L;
    private static Long minFlushSize = 3L;

    private static String baseDirectory = "/test/code/cache/";
    private static String fileNameFormat = "Table-";

    private static String  currentWriteFile = "";

    private static List<Object>  currentQueue = new LinkedList<Object>();
    private static List<Object>  lastQueue = new LinkedList<Object>();

    static{
        try {
            load();
        } catch (IOException e) {
            System.out.println("Unable To Load");
            e.printStackTrace();
        }
    }

    private static void load() throws IOException{
        File baseLocation = new File(baseDirectory);
        List<String> fileList = new ArrayList<String>();

        for(File entry : baseLocation.listFiles()){
            if(!entry.isDirectory() && entry.getName().contains(fileNameFormat)){
                fileList.add(entry.getAbsolutePath());
            }
        }

        Collections.sort(fileList);

        if(fileList.size()==0){
            //currentQueue = lastQueue = new ArrayList<Object>();
            currentWriteFile = baseDirectory + "Table-1";
            BufferedWriter writer = new BufferedWriter(new FileWriter(currentWriteFile));
            while (!lastQueue.isEmpty()){
                writer.write(lastQueue.get(0).toString()+ "\n");
                lastQueue.remove(0);
            }
            writer.close();
        }else{
            if(fileList.size()>0){
                    BufferedReader reader = new BufferedReader(new FileReader(fileList.get(0)));
                    String line=null;
                    while ((line=reader.readLine())!=null){
                        currentQueue.add(line);
                    }
                    reader.close();
                    File toDelete = new File(fileList.get(0));
                    toDelete.delete();
            }

            if(fileList.size()>0){
                BufferedReader reader = new BufferedReader(new FileReader(fileList.get(fileList.size()-1)));
                currentWriteFile = fileList.get(fileList.size()-1);
                String line=null;
                while ((line=reader.readLine())!=null){
                    lastQueue.add(line);
                }
                reader.close();
                //lastFileNameIndex=Long.parseLong(fileList.get(fileList.size()).substring(6, 9));
            }
        }

    }

    private void loadFirst() throws IOException{
        File baseLocation = new File(baseDirectory);
        List<String> fileList = new ArrayList<String>();

        for(File entry : baseLocation.listFiles()){
            if(!entry.isDirectory() && entry.getName().contains(fileNameFormat)){
                fileList.add(entry.getAbsolutePath());
            }
        }

        Collections.sort(fileList);

        if(fileList.size()>0){
                BufferedReader reader = new BufferedReader(new FileReader(fileList.get(0)));
                String line=null;
                while ((line=reader.readLine())!=null){
                    currentQueue.add(line);
                }
                reader.close();
                File toDelete = new File(fileList.get(0));
                toDelete.delete();
        }
    }

    public Object pop(){
        if(currentQueue.size()>0)
            return  currentQueue.remove(0);

        if(currentQueue.size()==0){
            try {
                loadFirst();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        if(currentQueue.size()>0)
            return  currentQueue.remove(0);
        else
            return null;
    }

    public synchronized Object waitTillPop() throws InterruptedException{
        if(currentQueue.size()==0){
            try {
                loadFirst();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if(currentQueue.size()==0)
                wait();
        }
        return currentQueue.remove(0);
    }

    public synchronized void push(Object data) throws IOException{
        lastQueue.add(data);
        this.notifyAll();
        if(lastQueue.size()>=minFlushSize){
            BufferedWriter writer = new BufferedWriter(new FileWriter(currentWriteFile));
            while (!lastQueue.isEmpty()){
                writer.write(lastQueue.get(0).toString() + "\n");
                lastQueue.remove(0);
            }
            writer.close();

            currentWriteFile  = currentWriteFile.substring(0,currentWriteFile.indexOf("-")+1) + 
                    (Integer.parseInt(currentWriteFile.substring(currentWriteFile.indexOf("-")+1,currentWriteFile.length())) + 1);
        }
    }

    public static void main(String[] args) {
        try {
            BlockingQueue bq = new BlockingQueue();

            for(int i =0 ; i<=8 ; i++){
                bq.push(""+i);
            }

            System.out.println(bq.pop());
            System.out.println(bq.pop());
            System.out.println(bq.pop());

            System.out.println(bq.waitTillPop());
            System.out.println(bq.waitTillPop());
            System.out.println(bq.waitTillPop());
            System.out.println(bq.waitTillPop());



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