1

イベントをリモート サーバーに非同期的に送信する Log4J アペンダーで構成されるライブラリを作成しています。ログステートメントが作成されると、アペンダーはイベントをローカルキューに非同期に記録し、コンシューマーのプールが取得してリモートに送信します。

完全なインメモリ ソリューションは、同時実行の問題を処理する BlockingQueue を作成することです。ただし、キューを永続化して、リモートサーバーが使用できない場合にキューを無制限に拡張したり、キューが制限されている場合にメッセージを破棄したりしないようにしたいと考えています。

組み込みの H2 データベースを使用してイベントをローカルに保存し、ポーリング メカニズムを使用してイベントを取得し、リモートに送信することを考えていました。データベース テーブルをポーリングするよりも、むしろ BlockingQueue を使用したいと思います。

JMS が答えですか?

編集：

JMS が答えであり、そのように進んでいると思われる場合、処理中のメッセージのみを受け入れるように構成できる、軽量で埋め込み可能な JMS ソリューションに関する推奨事項はありますか? 言い換えれば、リッスンする TCP ソケットを開きたくないし、おそらく許可されないでしょう。

編集：

現在、ActiveMQ が組み込まれており、動作しているようです。皆さんありがとう。

4

4 に答える 4

2

Bob Leeは、しばらく前に非常に単純なディスクバックアップキューをオープンソース化しました。https：//github.com/square/retrofit/blob/master/modules/android/src/retrofit/io/QueueFile.java-役立つ場合があります。ローカルの耐久性を受け入れることができれば、JMSよりも導入がはるかに簡単です。

このクラスはスタンドアロンです。コピーして貼り付けることができます。

于 2010-11-15T21:18:33.700 に答える
1

JMS を使用して、リモート マシンにメッセージを非同期的に送信できます (もちろん、メッセージを受信できると仮定します)。Log4j には、これに使用できる JMS アペンダーがあります。

于 2010-11-15T13:45:30.657 に答える
1

この目的で JMS を確実に使用できます。私が理解している限り、Log4J JMS アペンダーを使用しています。このコンポーネントは、事前構成された JMS 宛先 (通常はキュー) にメッセージを送信します。このキューを永続化するように構成できます。この場合、キューに挿入されたすべてのメッセージは、永続ストア (通常はデータベース) に自動的に格納されます。残念ながら、この構成はベンダー固有 (JMS ベンダーによって異なります) ですが、通常は非常に単純です。JMS プロバイダーのドキュメントを参照してください。

于 2010-11-15T13:57:08.790 に答える
0

これが機能するかどうかを確認してください

このコードは機能するはずです-メモリ内の永続的なブロックキューです-ファイルの調整が必要ですが、機能するはずです

       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();
        }
    }
于 2016-01-19T11:45:47.043 に答える