Vaadin 7.x CDIView菜单项导航选中状态异常及页面方法调用问题

Let's break down your two problems and walk through actionable fixes— I've dealt with these exact scenarios in Vaadin 7 CDI projects before, so here's what you can do:

1. Fixing Menu Item Selection State #

The core issue here is that your menu isn't syncing with the Navigator's view changes. Vaadin's Navigator fires ViewChangeListener events whenever the active view switches, so we can leverage this to update menu selections automatically.

Step-by-Step Implementation #

First, create a mapping between your view classes and their corresponding menu items. Then register a listener to update selections after each view change:

// In your UI class where you set up the menu and navigator
@Inject
private CDIViewProvider viewProvider;
private MenuBar mainMenu;
private Map<Class<? extends View>, MenuItem> viewToMenuItemMap = new HashMap<>();

@Override
protected void init(VaadinRequest request) {
    // Initialize content layout and navigator
    VerticalLayout content = new VerticalLayout();
    setContent(content);
    Navigator navigator = new Navigator(this, content);
    navigator.addProvider(viewProvider);

    // Build your menu and map views to menu items
    mainMenu = new MenuBar();
    content.addComponent(mainMenu);

    // Add menu items and link to views
    MenuItem buttonsItem = mainMenu.addItem("Buttons & Links", e -> 
        navigator.navigateTo(ButtonsLinksView.class.getName())
    );
    viewToMenuItemMap.put(ButtonsLinksView.class, buttonsItem);

    MenuItem labelsItem = mainMenu.addItem("Labels", e -> 
        navigator.navigateTo(LabelsView.class.getName())
    );
    viewToMenuItemMap.put(LabelsView.class, labelsItem);

    // Register ViewChangeListener to sync menu selection
    navigator.addViewChangeListener(new ViewChangeListener() {
        @Override
        public boolean beforeViewChange(ViewChangeEvent event) {
            return true; // Allow all view changes
        }

        @Override
        public void afterViewChange(ViewChangeEvent event) {
            // Deselect all menu items first
            mainMenu.getItems().forEach(item -> item.setSelected(false));
            
            // Get the newly activated view class and select its menu item
            Class<? extends View> activeViewClass = event.getNewView().getClass();
            MenuItem activeMenuItem = viewToMenuItemMap.get(activeViewClass);
            if (activeMenuItem != null) {
                activeMenuItem.setSelected(true);
            }
        }
    });
}

Bonus: Dynamic Menu Generation #

To avoid manually adding menu items for each new view, use CDI to discover all @CDIView-annotated classes and generate menu items automatically. Add a custom annotation like @ViewDisplayName to your views to set menu text:

// Custom annotation for view display names
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ViewDisplayName {
    String value();
}

// Add to your views
@CDIView
@ViewDisplayName("Buttons & Links")
public class ButtonsLinksView extends CustomComponent implements View { /* ... */ }

// In UI class, generate menu dynamically
@Inject
@Any
private Instance<View> allViews;

// Inside init()
for (View view : allViews) {
    CDIView cdiView = view.getClass().getAnnotation(CDIView.class);
    ViewDisplayName displayName = view.getClass().getAnnotation(ViewDisplayName.class);
    
    String viewName = cdiView.name().isEmpty() ? view.getClass().getName() : cdiView.name();
    String menuText = displayName != null ? displayName.value() : view.getClass().getSimpleName();
    
    MenuItem menuItem = mainMenu.addItem(menuText, e -> navigator.navigateTo(viewName));
    viewToMenuItemMap.put(view.getClass(), menuItem);
}

2. Calling a Specific Method on the Target View #

There are two reliable ways to trigger a method on your LabelsView when navigating from the "Open Labels" button:

Option 1: Use Navigation Parameters (Most Reliable) #

Pass a parameter in the navigation URL, then handle it in the target view's enter() method. This works even if the view is being initialized for the first time:

// In ButtonsLinksView, the button click handler
Button openLabelsBtn = new Button("Open Labels", click -> {
    // Add a parameter to indicate we need to run the specific method
    navigator.navigateTo(LabelsView.class.getName() + "?action=loadLabels");
});

Then in your LabelsView:

@CDIView
public class LabelsView extends CustomComponent implements View {
    @Override
    public void enter(ViewChangeEvent event) {
        // Parse the navigation parameter
        String actionParam = event.getParameters().get("action");
        
        // Trigger the specific method if the parameter matches
        if ("loadLabels".equals(actionParam)) {
            this.loadAndDisplayLabels(); // Your target method
        }
    }

    // Your specific method to call
    public void loadAndDisplayLabels() {
        // Add your business logic here (e.g., fetch data, update UI)
        Notification.show("Labels initialized via button click!");
    }
}

Option 2: Direct Method Call (For Existing Views) #

If your view is already cached (Vaadin 7's CDIView uses @ViewScoped by default, so instances are reused), you can fetch the view instance from the navigator and call the method directly before navigating. Note this won't work if the view hasn't been initialized yet:

// In ButtonsLinksView's button handler
Button openLabelsBtn = new Button("Open Labels", click -> {
    // Get the existing LabelsView instance (if it exists)
    LabelsView labelsView = (LabelsView) navigator.getView(LabelsView.class.getName());
    
    if (labelsView != null) {
        labelsView.loadAndDisplayLabels();
    }
    
    // Navigate to the view
    navigator.navigateTo(LabelsView.class.getName());
});

Additional Technical Tips #

• Ensure Proper CDI Setup: Make sure your Navigator uses the injected CDIViewProvider to handle view instantiation— this ensures CDI annotations like @Inject work correctly in your views.
• View Scoping: Vaadin 7's @ViewScoped keeps view instances alive as long as the user navigates between views, ideal for preserving state and avoiding redundant initializations.
• Clean Up Listeners: If you're dynamically generating menus or views, clean up listeners when the UI is detached to prevent memory leaks.

内容的提问来源于stack exchange，提问作者Reza P.