Question

I use MVC pattern for my project. btnAdd creates new Customer and adds MyJPanel1 as a listener. When Customer changes its state it fires event and customerChanged is called. When
MyJPanel1‘s customerChanged is called it does some action and

1. it has to stop listening to that Customer
2. other view/s has to start listen to that Customer

Some of other views will have the same behavior.
Those 2 requirements I implemented in MyJPanel1‘s customerChanged method itself.

UPADTED

My question and problem are:

1. Is this correct from the point of MVC or I should have some other entity(Controller?) that should handle it somehow?
2. When Customer fires fireEvent method so c.removeListener(this); in MyJPanel1 removes itself from listeners and by this cause error in fireEvent' becauselistenersinfor` loop was changed.

I’ll appreciate for some help.

class Customer {
    // ...

    private void fireEvent(CustomerEvent event) {
        for (IListener listener : listeners) {
            listener.customerChanged(event);
        }
    }
}

class MyJPanel1 extends JPanel implements IListener {
    MyJPanel2 otherPanel;

    MyJPanel1(MyJPanel2 panel) {
        this.otherPanel = panel;
        createGui();
    }

    private void createGui() {
        JButton btnAdd = new JButton("Add");
        btnAdd.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent arg0) {
                Customer c = new Customer();
                c.addListener(this);
            }
        });
        // ...
    }

    @Override
    public void customerChanged(CustomerEvent event) {
        if (event instanceof AddedCustomerEvent) {
            Customer c = event.getCustomer();
            // do something
            c.removeListener(this);
            c.addListener(otherPanel);
        }
    }
}

Answer 1

Views just display data; they never have any functionality on their own.

Changing things (like adding/removing listeners) is the purpose of the controller. It will hook up the model to the view and make sure that everything works. Make the view as dumb as possible.

Regarding your second problem: As you noticed, you can’t have listeners that commit suicide. There are several solutions:

1. Return a boolean from the listener saying “I’m done, remove me”. The loop would then be:

   for (Iterator<IListener> iter = listeners.iterator(); iter.hasNext(); ) {
       if (!listener.customerChanged(event)) {
           iter.remove();
       }
   }
   

2. Create a new listener that is never removed. Instead let this listener forward the events to the interested views. That means it will send the event to MyJPanel1 until that view is done with it. From now on, the event will go to the other views.

   A good solution would be to have the new listener listen to two events: The CustomerEvent and the IAmDoneEvent published by MyJPanel1.

   It has two lists of listeners. Until IAmDoneEvent is received, all CustomerEvent go to the first list. After this event, all CustomerEvent go to the second list. Add MyJPanel1 to the first list and all other views to the second list.

   Use your controller to build up this listener network.