java - 这个警告在 Vaadin : "Ignoring RPC call for disabled connector com.vaadin.ui.Window"? 中意味着什么

Question

我尝试在 google 上查找一些提示并查看 Vaadin 的网站，但没有找到与此问题之王相关的任何内容:

当我启动应用程序时，在控制台中，我多次看到此警告:

Ignoring RPC call for disabled connector com.vaadin.ui.Window, caption=Window's caption

我正在使用 Refresher 插件，它以 2000 毫秒的间隔轮询我的服务器。以及实现推送到 Vaadin UI 的 ICEPush 插件。

我认为这与 Refresher 插件有关，因为如果我与为测试创建的组件(在代码下方)交互，警告会添加到控制台。

这是代码:

package com.example.events;

import java.util.ArrayList;
import java.util.List;

import com.github.wolfie.refresher.Refresher;
import com.vaadin.event.FieldEvents.BlurListener;
import com.vaadin.event.FieldEvents.FocusListener;
import com.vaadin.event.FieldEvents.TextChangeEvent;
import com.vaadin.event.FieldEvents.TextChangeListener;
import com.vaadin.event.LayoutEvents.LayoutClickNotifier;
import com.vaadin.ui.AbstractTextField.TextChangeEventMode;
import com.vaadin.ui.Button;

import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Component;
import com.vaadin.ui.Label;
import com.vaadin.ui.Layout;
import com.vaadin.ui.Notification;
import com.vaadin.ui.TextArea;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.Window;

public class Noticeboard extends VerticalLayout {

    /**
     * 
     */
    private static final long serialVersionUID = -6023888496081433464L;

    private static List<Note> notes = new ArrayList<Note>();
    private List<Window> windows = new ArrayList<Window>();
    private static int userCount;
    private int userId;
    private static int noteId;
    private Refresher refresher = new Refresher();
    private static final int UPDATE_INTERVAL = 2000;
    private Note currentlyFocusedNote;

    public class NoticeboardUpdater extends Thread {

        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(UPDATE_INTERVAL);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                getUI().getSession().getLockInstance().lock();
                try {
                    updateNoticeboard();
                } finally {
                    getUI().getSession().getLockInstance().unlock();
                }
            }
        }

    }

    public Noticeboard() {
        refresher.setRefreshInterval(UPDATE_INTERVAL);
        userId = ++userCount;
        setSpacing(true);
        setMargin(true);
        addComponent(new Label("Logged in as User " + userId));
        Button addNoteButton = new Button("Add note");

        addNoteButton.addClickListener(new ClickListener() {

            /**
             * 
             */
            private static final long serialVersionUID = -4927018162887570343L;

            @Override
            public void buttonClick(ClickEvent event) {
                Note note = new Note(++noteId);
                note.setCaption("Note " + note.getId());
                notes.add(note);

                Window window = createWindow(note);
                windows.add(window);

                UI.getCurrent().addWindow(window);
            }
        });

        addComponent(addNoteButton);
        addExtension(refresher);        
        new NoticeboardUpdater().start();
    }

    private Window createWindow(final Note note) {
        final Window window = new Window(note.getCaption());
        VerticalLayout layout = new VerticalLayout();
        layout.addComponent(createContentNote(note, window));
        window.setContent(layout);
        window.setWidth(300, Unit.PIXELS);
        window.setResizable(false);
        window.setPositionX(note.getPositionX());
        window.setPositionY(note.getPositionY());
        window.setData(note);
        window.addBlurListener(createBlurListener(window));
        window.addFocusListener(createFocusListener(window));

        LayoutClickNotifier mainLayout = (LayoutClickNotifier) getUI().getContent();
        mainLayout.addLayoutClickListener(e -> {
            if (note.isNoteFocusedWindow() || note.isNoteFocusedTextArea()) {               
                if (note.getLockedByUser() > -1 && note.getLockedByUser() == userId) {                  
                    unlockNote(getWindow(currentlyFocusedNote));
                    note.setNoteFocusedWindow(false);
                    note.setNoteBlurredWindow(false);
                    note.setNoteFocusedTextArea(false);
                    note.setNoteBlurredTextArea(false);                 

                    currentlyFocusedNote = null;
                }
            }
        });

        return window;
    }

    private TextArea createContentNote(final Note note, final Window window) {
        TextArea contentNote = new TextArea();
        contentNote.setSizeFull();
        contentNote.setValue(note.getText());
        contentNote.setImmediate(true);
        contentNote.setTextChangeEventMode(TextChangeEventMode.EAGER);
        contentNote.addBlurListener(createBlurListener(window));
        contentNote.addFocusListener(createFocusListener(window));
        contentNote.addTextChangeListener(new TextChangeListener() {

            /**
             * 
             */
            private static final long serialVersionUID = 8552875156973567499L;

            @Override
            public void textChange(TextChangeEvent event) {
                note.setText(event.getText());
            }
        });
        return contentNote;
    }

    private BlurListener createBlurListener(Window window) {
        return e -> {
            Component blurredComponent = e.getComponent();

            if (blurredComponent == window)  {
                currentlyFocusedNote.setNoteBlurredWindow(true);
            }
            else if (blurredComponent == (((Layout) window.getContent())).iterator().next()) {
                currentlyFocusedNote.setNoteBlurredTextArea(true);
            }

        };
    }

    private FocusListener createFocusListener(Window window) {
        return e -> {
            Component focusedComponent = e.getComponent();
            Note note = (Note) window.getData();

            if (currentlyFocusedNote != null && currentlyFocusedNote != note) {
                unlockNote(getWindow(currentlyFocusedNote));        
                currentlyFocusedNote.setNoteFocusedWindow(false);
                currentlyFocusedNote.setNoteBlurredWindow(false);
                currentlyFocusedNote.setNoteFocusedTextArea(false);
                currentlyFocusedNote.setNoteBlurredTextArea(false);
            }

            currentlyFocusedNote = note;
            if (focusedComponent == window) {
                Notification.show("Focused Note Window");
                currentlyFocusedNote.setNoteFocusedWindow(true);
            }
            else if (focusedComponent == (((Layout) window.getContent())).iterator().next()) {
                Notification.show("Focused Note TextArea");
                currentlyFocusedNote.setNoteFocusedTextArea(true);
            }

            if (currentlyFocusedNote.isNoteFocusedWindow() && currentlyFocusedNote.isNoteBlurredTextArea() || 
                currentlyFocusedNote.isNoteFocusedTextArea() && currentlyFocusedNote.isNoteBlurredWindow()) {
                // Lock is already set here, skipping
                return;
            }                       
            lockNote(window);
        };
    }

    private void lockNote(Window window) {
        Note note = (Note) window.getData();
        note.setLockedByUser(userId);
        String caption = "Locked by User " + userId;
        note.setCaption(caption);
        window.setCaption(caption);
    }

    private void unlockNote(Window window) {
        Note note = (Note) window.getData();
        note.setLockedByUser(-1);
        note.setPositionX(window.getPositionX());
        note.setPositionY(window.getPositionY());
        note.setCaption("Note " + note.getId());
        window.setCaption("Note " + note.getId());
    }

    private void updateNoticeboard() {
        for (Note note : notes) {
            Window window = getWindow(note);

            if (window == null) {
                window = createWindow(note);
                windows.add(window);
                UI.getCurrent().addWindow(window);
            }

            if (note.getLockedByUser() > -1) {
                if (note.getLockedByUser() != userId) {
                    // If the note is locked by another user, then we disable this window. 
                    window.setEnabled(false);

                    updateTextArea(window, note);                   
                    updateWindowPosition(window, note);
                }
                else {                  
                    // Otherwise the window is enabled.
                    window.setEnabled(true);
                    Note focusedNote = (Note) window.getData();

                    updateFocusedNotePosition(focusedNote, window);
                }
            }           
            else {
                window.setEnabled(true);
                updateTextArea(window, note);
                updateWindowPosition(window, note);
            }           
        }
    }

    private void updateTextArea(Window window, Note note) {
        Layout layout = (Layout) window.getContent();
        TextArea area = (TextArea) layout.iterator().next();
        area.setValue(note.getText());
    }

    private Window getWindow(Note note) {
        for (Window window : windows) {
            if (window.getData().equals(note))
                return window;
        }
        return null;
    }

    private void updateWindowPosition(Window window, Note note) {
        window.setPositionX(note.getPositionX());
        window.setPositionY(note.getPositionY());
        window.setCaption(note.getCaption());
    }

    private void updateFocusedNotePosition(Note focusedNote, Window window) {       
        focusedNote.setPositionX(window.getPositionX());
        focusedNote.setPositionY(window.getPositionY());
        focusedNote.setCaption(window.getCaption());
    }
}

在 UI 的 init 方法中，我只需使用此Noticeboard 类:

@Override
protected void init(VaadinRequest request) {
    setContent(new Noticeboard());
}

当我移动使用“添加注释”按钮创建的窗口或将焦点从一个窗口更改到另一个窗口时，我会遇到警告。

出现此类问题的原因可能是什么？

我知道，代码并不是更好的代码，只是为了看看这个 Vaadin 插件的行为如何。

Answer 1

当您禁用组件时，禁用状态会在客户端和服务器端处理，这意味着组件不仅在视觉上被禁用，而且服务器也会拒绝处理对禁用组件的任何请求。

您看到的警告意味着存在针对已禁用组件的 RPC 请求(来自客户端的 HTTP 请求)。由于该组件被禁用，RPC 请求将被忽略。

当您有一个禁用组件的后台线程，然后还从客户端进行轮询时，通常会发生这种情况。