Jak wiem w standardowej implementacji MVC przekazujemy kontroler i model do widoku

Ale trochę się z tym nie zgadzam. Nie chcę, aby mój pogląd wiedział zarówno o kontrolerze, jak i modelu (o nie. Może czasami zobaczyć model, ale jestem pewien, że może żyć bez znajomości kontrolera)

Moim zdaniem Kontroler powinien zarządzać widokiem i modelem, a model nie musi wiedzieć o kontrolerze i widoku; widok nie musi znać kontrolera (nie wykluczam modelu, ponieważ niektóre implementacje widoków muszą wiedzieć o modelu, aby nasłuchiwać zmian w modelu). Więc mój pomysł jest takiwidok nie musi wiedzieć o kontrolerze.

1 Oto jeden przykład:

public class MyView implements ButtonClickListener {

    private Controller myController;
    private Button myButton;

    // I commented out the model because we dont need it now 
    // we are talking about using controller in the view

    public MyView(Controller c/*, Model m*/) {
        myController  = c;
        myButton      = new Button(); // lets say that it is "register" button
        myButton.setOnButtonClickListener(this);
    }

    public void setRegisterButtonText(String text) {
        myButton.setText(text);
    }

    @Override
    public void onClick() {
        myController.tellToModelToDoSomething();
    }

}

I kontroler:

public MyController implements Controller {

     private Model model;
     private View view;

     public MyController(Model model) {

          this.model = model;
          this.view  = new MyView(this);

     }

     public void tellToModelToDoSomething() {
          model.doSomeActions();
     }


}

2. A teraz jak mogę zobaczyć tę implementację bez podania kontrolera:

Mój widok:

public class MyView {

    private Button myButton;

    public MyView() {
        myButton = new Button();
    }

    public void setRegisterButtonText(String text) {
        myButton.setText(text);
    }

    public void setOnRegisterButtonClick(final Command command) {
        myButton.setOnButtonClickListener(new ButtonClickListener() {
                            @Override
                            public void onClick() {
                                command.execute();
                            }
                         });
    }

}

Interfejs „Command”:

public interface Command {

     void execute(/*also can handle extra params*/);

}

I kontroler:

public MyController implements Controller {

 private Model model;
 private View view;

 public MyController(Model model) {

      this.model = model;
      this.view  = new MyView();

      view.setOnRegisterButtonClick(command);

 }

 public void tellToModelToDoSomething() {
      model.doSomeActions();
 }

 private Command command = new Command() {

     public void execute() {
          tellToModelToDoSomething();
     }

 };

}

Dlaczego więc uważam, że użycie kontrolera w widokuNIE JEST DOBRZE:

Miksujemy kontroler i przeglądamy implementacje, tworząc nowe zależności.

Myślę też, że View powinien zawierać tylko VIEWS i operacje z nimi (i używając kontrolera, a niektóre z jego metod już wyglądają jak logika).

W pierwszym przykładzie widok informuje kontrolera, co robić. Zgadzasz się? Wygląda na to, że widok kontroluje kontroler!

W drugim przykładzie kontroler kontroluje, co robić i po prostu mówi do widoku, co zrobić, jeśli jakiś przycisk (tylko widok wie, jaki przycisk będzie) kliknięty

Zawsze korzystałem z drugiego schematu, ale po przeczytaniu nowej książki o mvc, która mówi, że musimy przekazać kontroler do widoku, jestem trochę mylący.

Czy możesz mi pomóc zrozumieć, dlaczego się mylę i pokazać kilka przykładów?