使用Observer模式在Main类中获取数据

Question

我正在从远程API获取JSON数据。 为此，我使用了观察者模式。 我创建了一个名为WordTranslationObserver的观察器，该观察器从回调方法获取JSON数据。 问题是我不知道如何在Main类中获取此数据...

在我的主类中，我无法实现PropertyChangeListener，也无法使用translationModel.addChangeListener（this），因为我处于静态上下文中，因此“ this”无法正常工作。

从我的Main类中的translation.getText（）获取数据的正确方法是什么？

主班

public class Main    {
    public static void main(String[] args) throws IOException {

        WordTranslation wordTranslation = new WordTranslation();
        WordTranslationObserver myObserver = new WordTranslationObserver(wordTranslation);
        wordTranslation.translate("sắt", "vie", "eng");     

    }
}

观察者

public class WordTranslationObserver implements PropertyChangeListener {
    public WordTranslationObserver(WordTranslation translationModel) {
        translationModel.addChangeListener(this);
    }

    @Override
    public void propertyChange(PropertyChangeEvent event) {
        System.out.println("Changed property: " + event.getPropertyName());
        ArrayList<Translation> translations = (ArrayList<Translation>) event.getNewValue();

        // Print recieved data from JSON to the console 
        // I want to be able to get translation.getText() in my Main class
        for (Translation translation : translations) {
            System.out.println(translation.getText());
        }
    }
}

数据

public class WordTranslation {
    public static final String TRANSLATIONS = "translations";
    private static final String BASE_URL = "http://deu.hablaa.com/hs/translation/";
    private List<PropertyChangeListener> listener = new ArrayList<PropertyChangeListener>();
    ArrayList<Translation> translations;    

     public void addChangeListener(PropertyChangeListener newListener) {
            listener.add(newListener);
     }


     public void notifyListeners(String property, Translation[] translationArray) {
            translations = new ArrayList<>();
            // TODO Auto-generated method stub
            for (Translation t : translationArray) {
                translations.add(t);
            }
            for (PropertyChangeListener name : listener) {
                name.propertyChange(new PropertyChangeEvent(this, "translations", null, translations));
        }
    } 

     public void translate(String word, String from, String to) {
            final Translation[][] translations = new Translation[1][1];

            String url = String.format("%s%s/%s-%s",BASE_URL, word, from, to);//  args) "http://xxx";
        System.out.println(url);
        final Gson gson = new Gson();

        // should be a singleton
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
                             .url(url)
                             .build();


        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }

                translations[0] = gson.fromJson(response.body().charStream(),Translation[].class);  
                notifyListeners(TRANSLATIONS,translations[0]);

            }
            });

        }

}

Answer 1

如果您确实愿意，可以让观察者设置静态变量，可以对其进行轮询以获取更改，但这将违反使用事件驱动的观察者模式的原理。

也许有某些特定的原因使您希望在主类中提供此信息，但是我将更倾向于将所有处理工作转移给观察者，因为您已经（干净地）完成了这些工作，并在需要时添加了新的实现。

如果您只是想让您的主类可以使用该信息（不一定在静态上下文中），请让您的主类实现PropertyChangeListener并以与WorldTranslationObserver相同的方式向WorldTranslation注册一个新的Main（）。

高温超导