Uno de los patrones de diseño que me parece más difícil conseguir un conocimiento real de real de Swing de la vida» es el patrón MVC. He sido a través de algunos de los puestos en este sitio que discutir el patrón, pero yo todavía no siento que tenga un claro entendimiento de cómo aprovechar el patrón en mi aplicación Java Swing.

Digamos que tengo un JFrame que contiene una tabla, un par de campos de texto y un par de botones. Probablemente yo uso un TableModel para «salvar» el JTable con un modelo de datos subyacente. Sin embargo, todas las funciones de responsable para la limpieza de los campos, la validación de los campos, el bloqueo de los campos junto con el botón de acciones suelen ir directamente en el JFrame. Sin embargo, no tiene que mezclar el Controlador y la Vista del patrón?

Tan lejos como puedo ver, me las arreglo para conseguir el patrón MVC «correctamente» que se implementa cuando se mira en el JTable (y el modelo), pero las cosas se fangoso cuando me mira todo el JFrame como un todo.

Realmente me gustaría escuchar cómo otros se van, con respecto a esto. ¿Cómo usted va sobre cuando usted necesita para mostrar una tabla, un par de campos y algunos botones para un usuario utilizando el patrón MVC?

  • Aquí está una relacionada con el ejemplo.
  • Para cualquier persona que viene a este partido – Swing NO es un puro MVC – incorpora fuertes desde el concepto, pero «se derrumba» la «vista y el controlador» juntos
InformationsquelleAutor sbrattla | 2011-03-07

7 Comentarios

  1. 102

    Un libro que le recomiendo a usted para MVC en swing sería «Head First Design patterns» de Freeman y Freeman. Tienen una muy completa explicación de la MVC.

    Breve Resumen

    1. Usted es el que el usuario puede interactuar con la vista. La vista de tu ventana a la modelo. Cuando haces algo que a la vista (como haga clic en el
      Botón de reproducción), a continuación, la vista se le dice al controlador de lo que hizo. Es el
      controlador del trabajo manejar eso.

    2. El controlador solicita el modelo para cambiar su estado. El controlador toma sus acciones y las interpreta. Si hace clic en un
      botón, es el controlador del trabajo de averiguar lo que significa y
      cómo el modelo debe ser manipuladas con base en esa acción.

    3. El controlador también puede pedir a la vista para cambiar. Cuando el controlador recibe una acción desde el punto de vista, se puede necesitar decirle al
      vista a cambiar como resultado. Por ejemplo, el controlador podría permitir
      o deshabilitar ciertos botones o elementos de menú en la interfaz.

    4. El modelo notifica a la vista cuando su estado ha cambiado. Cuando algo cambia en el modelo, basado en alguna acción que tomó
      (como hacer clic en un botón) o algún otro cambio interno (como la siguiente
      canción en la lista de reproducción se ha iniciado), el modelo notifica a la vista de que
      su estado ha cambiado.

    5. La vista pide el modelo de estado. La vista obtiene el estado en el que se muestra directamente a partir del modelo. Por ejemplo, cuando el modelo
      notifica el punto de vista de que una nueva canción ha empezado a jugar, a la vista de
      solicita el nombre de la canción de la modelo y la muestra. La vista puede
      también pedimos el modelo de estado como el resultado de la controladora
      solicita algún cambio en la vista.

    El patrón MVC y el Swing
    Fuente (En caso de que usted se está preguntando qué es un «cremoso controlador» es, creo que de una galleta Oreo, con el controlador de ser cremoso, el centro, el punto de vista de la parte superior de la galleta y el modelo de la parte inferior de la galleta.)

    Um, en caso de que usted está interesado, usted puede descargar una manera bastante entretenida canción sobre el patrón MVC de aquí!

    Un problema que puede enfrentar con el Swing de programación consiste en la fusión de toda la SwingWorker y EventDispatch hilo con el patrón MVC. Dependiendo de su programa, la vista o el controlador podría tener que ampliar la SwingWorker y anular el doInBackground() método donde el uso intensivo de los recursos de la lógica en que se coloca. Esto puede ser fácilmente fusionado con el típico patrón MVC, y es típico de las aplicaciones Swing.

    EDITAR #1:

    Además, es importante considerar MVC como una especie de compuesto de varios patrones. Por ejemplo, el modelo puede ser implementado utilizando el patrón Observer (que requieren la Vista para ser registrado como un observador para el modelo), mientras que su controlador puede utilizar el patrón de Estrategia.

    EDICIÓN #2:

    Me gustaría, además, como para responder específicamente a su pregunta. Usted debe mostrar su tabla de botones, etc en la Vista, lo cual, obviamente, sería implementar un ActionListener. En su actionPerformed() método, detectar el evento y enviarlo a un método en el controlador (recuerda que la vista contiene una referencia al controlador). Así que cuando hace clic en un botón, el evento es detectado por la vista, enviada al controlador del método, el controlador podría preguntar directamente a la vista para desactivar el botón o algo. A continuación, el controlador de interactuar y modificar el modelo (que la mayoría de los métodos getter y setter, y algunos otros para registrar y notificar los observadores y así sucesivamente). Tan pronto como el modelo es modificado, se llamará a una actualización acerca del registro de los observadores (esta será la vista en su caso). Por lo tanto, el punto de vista ahora la actualización de sí mismo.

    • He reales de leer el libro, pero he encontrado que es difícil aplicar el patrón de OSCILACIÓN. También he leído un par de lugares que ha leído que un JFrame también puede ser visto como el que representa una vista y un controlador.
    • … el JFrame es un componente, y no una hoja. normalmente, las actualizaciones realizadas por el controlador envía al JFrame, que se ocupa del resto, por lo tanto, esto puede dar la ilusión de que sea un controlador, pero en realidad, este no es el caso porque no ha cambiado el modelo, sólo a la vista. si tu JFrame de alguna manera ha cambiado el modelo directamente – lo estás haciendo mal.
    • … de nuevo, la palabra clave aquí es «directamente». en su caso, usted podría escuchar de clics en la mesa, y enviar la lógica de los métodos en el controlador que modificar el modelo de mesa.
    • El segundo punto de la descripción es para el tercer punto, el tercer y para que los puntos tienen la misma duplicado descripciones. Puede corregir, por favor.
    • Esa canción es un clásico! =D
  2. 34

    No me gusta la idea de que la vista está el que sea notificado por el modelo cuando sus cambios de datos. Me gustaría delegado que la funcionalidad del controlador. En ese caso, si cambia la lógica de la aplicación, usted no necesita interferir la vista de código. El punto de vista de la tarea es sólo para las aplicaciones de componentes + diseño nada más y nada menos. Publicación en el swing es ya un detallado tarea, ¿por qué dejarlo interferir con las aplicaciones de la lógica?

    Mi idea de MVC (que estoy trabajando en la actualidad, tan lejos y tan bien) es :

    1. La vista es el más tonto de los tres. No sabe nada sobre el controlador y el modelo. Su preocupación es sólo los componentes swing’ prostethics y el diseño.
    2. El modelo también es tonto, pero no tan tonto como el de la vista. Realiza las siguientes funcionalidades.
      • una. cuando uno de sus setter es llamada por el controlador, se le incendio la notificación a sus oyentes/observadores (como he dicho, me gustaría deligate este papel en el controlador). Yo prefiero SwingPropertyChangeSupport para lograr esto, desde su ya optimizado para este propósito.
      • b. base de datos de la funcionalidad de interacción.
    3. Una muy controlador inteligente. Conoce la vista y el modelo muy bien. El controlador tiene dos funcionalidades:
      • una. Se define la acción que se ejecutará cuando el usuario interactúa con él.
      • b. Escucha la modelo. Como lo he dicho, cuando el setter de la modelo se llama, el modelo de bomberos de notificación para el controlador. Es el controlador del trabajo interpretar esta notificación. Es posible que tenga que reflejar el cambio a la vista.

    Ejemplo De Código

    La Vista :

    Como me dijo la creación de la vista ya está detallado para crear su propia aplicación 🙂

    interface View{
        JTextField getTxtFirstName();
        JTextField getTxtLastName();
        JTextField getTxtAddress();
    }

    Es ideal para la interfaz de las tres de la capacidad de prueba a los efectos. Yo sólo proporciona la implementación de mi Modelo y el Controlador.

    El Modelo :

    public class MyImplementationOfModel implements Model{
        ...
        private SwingPropertyChangeSupport propChangeFirer;
        private String address;
        private String firstName;
        private String lastName;
    
        public MyImplementationOfModel() {
            propChangeFirer = new SwingPropertyChangeSupport(this);
        }
        public void addListener(PropertyChangeListener prop) {
            propChangeFirer.addPropertyChangeListener(prop);
        }
        public void setAddress(String address){
            String oldVal = this.address;
            this.address = address;
    
            //after executing this, the controller will be notified that the new address has been set. Its then the controller's
            //task to decide what to do when the address in the model has changed. Ideally, the controller will update the view about this
            propChangeFirer.firePropertyChange("address", oldVal, address);
        }
        ...
        //some other setters for other properties & code for database interaction
        ...
    }

    El Controlador :

    public class MyImplementationOfController implements PropertyChangeListener, Controller{
    
        private View view;
        private Model model;
    
        public MyImplementationOfController(View view, Model model){
            this.view = view;
            this.model = model;
    
            //register the controller as the listener of the model
            this.model.addListener(this);
    
            setUpViewEvents();
        }
    
        //code for setting the actions to be performed when the user interacts to the view.
        private void setUpViewEvents(){
            view.getBtnClear().setAction(new AbstractAction("Clear") { 
                @Override
                public void actionPerformed(ActionEvent arg0) {
                    model.setFirstName("");
                    model.setLastName("");
                    model.setAddress("");
                }
            });
    
            view.getBtnSave().setAction(new AbstractAction("Save") { 
                @Override
                public void actionPerformed(ActionEvent arg0) {
                    ...
                    //validate etc.
                    ...
                    model.setFirstName(view.getTxtFName().getText());
                    model.setLastName(view.getTxtLName().getText());
                    model.setAddress(view.getTxtAddress().getText());
                    model.save();
                }
            });
        }
    
        public void propertyChange(PropertyChangeEvent evt){
            String propName = evt.getPropertyName();
            Object newVal = evt.getNewValue();
    
            if("address".equalsIgnoreCase(propName)){
                view.getTxtAddress().setText((String)newVal);
            }
            //else  if property (name) that fired the change event is first name property
            //else  if property (name) that fired the change event is last name property
        }
    }

    La Principal, donde el MVC es la instalación :

    public class Main{
        public static void main(String[] args){
            View view = new YourImplementationOfView();
            Model model = new MyImplementationOfModel();
    
            ...
            //create jframe
            //frame.add(view.getUI());
            ...
    
            //make sure the view and model is fully initialized before letting the controller control them.
            Controller controller = new MyImplementationOfController(view, model);
    
            ...
            //frame.setVisible(true);
            ...
        }
    }
    • Muy interesante, pero es menos eficiente cuando una sola entidad modelo se muestra en múltiples puntos de vista… Entonces su diseño puede conducir a un «mayor control» de la manipulación de un modelo único, pero la gestión de todos los relacionados con las vistas. Y se hace aún más complicado si se intenta reutilizar un conjunto de «pequeño modelo», gracias a una agregación en un «modelo grande» porque una vista muestra información se distribuye en varios pequeños «modelo» de las entidades.
    • Sólo traté de sus códigos. Cuando se pulse un botón, puedo conseguir los códigos en setUpViewEvents() al fuego. Sin embargo, cuando hago un modelo.setSomething(123), los códigos de propertyChange no despidan. Incluso poner una println directamente en el Objeto newVal = evt.getNewValue(); y no imprimir.
    • Este NO es el MVC patrón de arquitectura, pero el estrechamente relacionados MVP (Modelo-Vista-Presentador) el patrón. En un típico MVC, es precisamente el modelo de trabajo de notificar a la vista cuando se ha cambiado, exactamente lo que «no le gusta». Mira este diagrama para ver cómo las interacciones en un típico MVC trabajo.
  3. 22

    El patrón MVC es un modelo de cómo una interfaz de usuario puede ser estructurado.
    Por lo tanto, define los 3 elementos del Modelo, Vista, Controlador:

    • Modelo Un modelo es una abstracción de algo que se presenta al usuario. En swing tiene una diferenciación de gui modelos y modelos de datos. GUI modelos resumen el estado de un componente de interfaz de usuario como ButtonModel. Modelos de datos abstractos de datos estructurados que la interfaz de usuario se presenta al usuario como TableModel.
    • Ver La vista es un componente de interfaz de usuario que es el responsable de presentar los datos al usuario. Por lo tanto es responsable de toda la interfaz de usuario dependiente de temas como el diseño, el dibujo, etc. E. g. JTable.
    • Controlador de Un controlador de encapsula el código de la aplicación que se ejecuta en orden a una interacción con el usuario (movimiento del ratón, clic con el ratón, pulsar la tecla, etc.). Los controladores pueden necesitar de entrada para su ejecución y que producen a la salida. Pueden leer a su entrada a partir de modelos y actualización de los modelos como resultado de la ejecución. También podrían reestructurar la interfaz de usuario (por ejemplo, reemplazar componentes de interfaz de usuario o mostrar una nueva visión). Sin embargo no deben saber acerca de la interfaz de usuario compoenents, porque usted puede encapsular la reestructuración en una interfaz independiente de que el controlador sólo invoca. En el swing de un controlador es normalmente implementado por un ActionListener o Acción.

    Ejemplo

    • Rojo = modelo
    • Verde = view
    • Azul = controlador de

    El patrón MVC y el Swing

    Cuando el Button se hace clic invoca la ActionListener. El ActionListener sólo depende de otros modelos. Utiliza algunos modelos como el de entrada y el de los demás, ya que el resultado o la salida. Es como método de argumentos y valores de retorno. Los modelos de notificar a la interfaz de usuario cuando se actualizan. Así que no hay necesidad de que el controlador de lógica para saber el componente de interfaz de usuario. El modelo de objetos no conocen la interfaz de usuario. La notificación se realiza por un observador patrón. Así, el modelo de objetos sólo saber que hay alguien que quiere ser notificado si los cambios en el modelo.

    En java swing hay algunos componentes que implementan un modelo y un controlador así. E. g. el javax.el swing.Acción. Se implementa un modelo de interfaz de usuario (propiedades: habilitación, pequeño icono, nombre, etc.) y es un controlador porque se extiende ActionListener.

    Un explicación detallada, ejemplo de la aplicación y el código fuente: https://www.link-intersystems.com/blog/2013/07/20/the-mvc-pattern-implemented-with-java-swing/.

    MVC básicos en menos de 240 líneas:

    public class Main {
    public static void main(String[] args) {
    JFrame mainFrame = new JFrame("MVC example");
    mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    mainFrame.setSize(640, 300);
    mainFrame.setLocationRelativeTo(null);
    PersonService personService = new PersonServiceMock();
    DefaultListModel searchResultListModel = new DefaultListModel();
    DefaultListSelectionModel searchResultSelectionModel = new DefaultListSelectionModel();
    searchResultSelectionModel
    .setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    Document searchInput = new PlainDocument();
    PersonDetailsAction personDetailsAction = new PersonDetailsAction(
    searchResultSelectionModel, searchResultListModel);
    personDetailsAction.putValue(Action.NAME, "Person Details");
    Action searchPersonAction = new SearchPersonAction(searchInput,
    searchResultListModel, personService);
    searchPersonAction.putValue(Action.NAME, "Search");
    Container contentPane = mainFrame.getContentPane();
    JPanel searchInputPanel = new JPanel();
    searchInputPanel.setLayout(new BorderLayout());
    JTextField searchField = new JTextField(searchInput, null, 0);
    searchInputPanel.add(searchField, BorderLayout.CENTER);
    searchField.addActionListener(searchPersonAction);
    JButton searchButton = new JButton(searchPersonAction);
    searchInputPanel.add(searchButton, BorderLayout.EAST);
    JList searchResultList = new JList();
    searchResultList.setModel(searchResultListModel);
    searchResultList.setSelectionModel(searchResultSelectionModel);
    JPanel searchResultPanel = new JPanel();
    searchResultPanel.setLayout(new BorderLayout());
    JScrollPane scrollableSearchResult = new JScrollPane(searchResultList);
    searchResultPanel.add(scrollableSearchResult, BorderLayout.CENTER);
    JPanel selectionOptionsPanel = new JPanel();
    JButton showPersonDetailsButton = new JButton(personDetailsAction);
    selectionOptionsPanel.add(showPersonDetailsButton);
    contentPane.add(searchInputPanel, BorderLayout.NORTH);
    contentPane.add(searchResultPanel, BorderLayout.CENTER);
    contentPane.add(selectionOptionsPanel, BorderLayout.SOUTH);
    mainFrame.setVisible(true);
    }
    }
    class PersonDetailsAction extends AbstractAction {
    private static final long serialVersionUID = -8816163868526676625L;
    private ListSelectionModel personSelectionModel;
    private DefaultListModel personListModel;
    public PersonDetailsAction(ListSelectionModel personSelectionModel,
    DefaultListModel personListModel) {
    boolean unsupportedSelectionMode = personSelectionModel
    .getSelectionMode() != ListSelectionModel.SINGLE_SELECTION;
    if (unsupportedSelectionMode) {
    throw new IllegalArgumentException(
    "PersonDetailAction can only handle single list selections. "
    + "Please set the list selection mode to ListSelectionModel.SINGLE_SELECTION");
    }
    this.personSelectionModel = personSelectionModel;
    this.personListModel = personListModel;
    personSelectionModel
    .addListSelectionListener(new ListSelectionListener() {
    public void valueChanged(ListSelectionEvent e) {
    ListSelectionModel listSelectionModel = (ListSelectionModel) e
    .getSource();
    updateEnablement(listSelectionModel);
    }
    });
    updateEnablement(personSelectionModel);
    }
    public void actionPerformed(ActionEvent e) {
    int selectionIndex = personSelectionModel.getMinSelectionIndex();
    PersonElementModel personElementModel = (PersonElementModel) personListModel
    .get(selectionIndex);
    Person person = personElementModel.getPerson();
    String personDetials = createPersonDetails(person);
    JOptionPane.showMessageDialog(null, personDetials);
    }
    private String createPersonDetails(Person person) {
    return person.getId() + ": " + person.getFirstName() + " "
    + person.getLastName();
    }
    private void updateEnablement(ListSelectionModel listSelectionModel) {
    boolean emptySelection = listSelectionModel.isSelectionEmpty();
    setEnabled(!emptySelection);
    }
    }
    class SearchPersonAction extends AbstractAction {
    private static final long serialVersionUID = 4083406832930707444L;
    private Document searchInput;
    private DefaultListModel searchResult;
    private PersonService personService;
    public SearchPersonAction(Document searchInput,
    DefaultListModel searchResult, PersonService personService) {
    this.searchInput = searchInput;
    this.searchResult = searchResult;
    this.personService = personService;
    }
    public void actionPerformed(ActionEvent e) {
    String searchString = getSearchString();
    List<Person> matchedPersons = personService.searchPersons(searchString);
    searchResult.clear();
    for (Person person : matchedPersons) {
    Object elementModel = new PersonElementModel(person);
    searchResult.addElement(elementModel);
    }
    }
    private String getSearchString() {
    try {
    return searchInput.getText(0, searchInput.getLength());
    } catch (BadLocationException e) {
    return null;
    }
    }
    }
    class PersonElementModel {
    private Person person;
    public PersonElementModel(Person person) {
    this.person = person;
    }
    public Person getPerson() {
    return person;
    }
    @Override
    public String toString() {
    return person.getFirstName() + ", " + person.getLastName();
    }
    }
    interface PersonService {
    List<Person> searchPersons(String searchString);
    }
    class Person {
    private int id;
    private String firstName;
    private String lastName;
    public Person(int id, String firstName, String lastName) {
    this.id = id;
    this.firstName = firstName;
    this.lastName = lastName;
    }
    public int getId() {
    return id;
    }
    public String getFirstName() {
    return firstName;
    }
    public String getLastName() {
    return lastName;
    }
    }
    class PersonServiceMock implements PersonService {
    private List<Person> personDB;
    public PersonServiceMock() {
    personDB = new ArrayList<Person>();
    personDB.add(new Person(1, "Graham", "Parrish"));
    personDB.add(new Person(2, "Daniel", "Hendrix"));
    personDB.add(new Person(3, "Rachel", "Holman"));
    personDB.add(new Person(4, "Sarah", "Todd"));
    personDB.add(new Person(5, "Talon", "Wolf"));
    personDB.add(new Person(6, "Josephine", "Dunn"));
    personDB.add(new Person(7, "Benjamin", "Hebert"));
    personDB.add(new Person(8, "Lacota", "Browning "));
    personDB.add(new Person(9, "Sydney", "Ayers"));
    personDB.add(new Person(10, "Dustin", "Stephens"));
    personDB.add(new Person(11, "Cara", "Moss"));
    personDB.add(new Person(12, "Teegan", "Dillard"));
    personDB.add(new Person(13, "Dai", "Yates"));
    personDB.add(new Person(14, "Nora", "Garza"));
    }
    public List<Person> searchPersons(String searchString) {
    List<Person> matches = new ArrayList<Person>();
    if (searchString == null) {
    return matches;
    }
    for (Person person : personDB) {
    if (person.getFirstName().contains(searchString)
    || person.getLastName().contains(searchString)) {
    matches.add(person);
    }
    }
    return matches;
    }
    }
    • Me gusta esta respuesta +1 , por mencionar Action como Controller de hecho supongo que todos EventListener son los controladores..
    • Sí, en efecto. Como he dicho A controller encapsulates the application code that is executed in order to an user interaction. Mover el ratón, hacer clic en un componente, pulse una tecla, etc. son todas las interacciones del usuario. Para hacerlo más claro que he actualizado mi respuesta.
  4. 2

    Puede crear el modelo en una hoja separada, llanura de clase de Java, y un controlador de otro.

    Entonces usted puede tener componentes Swing en la parte superior de eso. JTable sería uno de los puntos de vista (y en la tabla modelo de facto ser parte de la vista – sólo iba a traducir desde el «modelo compartido» para JTable).

    Cada vez que la tabla está editado, su modelo de mesa dice que el «principal responsable» de actualizar algo. Sin embargo, el controlador debe saber nada sobre la mesa. Por lo que la llamada debe verse más como: updateCustomer(customer, newValue), no updateCustomer(row, column, newValue).

    Añadir un listener (observador) de la interfaz para el modelo compartido. Algunos componentes (por ejemplo, su tabla) se puede aplicar directamente. Otro observador podría ser el controlador que coordina el botón disponibilidad etc.


    Que es una manera de hacerlo, pero, por supuesto, usted puede simplificar o ampliar lo que sería una exageración para el caso de uso.

    Puede combinar el controlador con modelo y tienen la misma clase de proceso de actualizaciones y mantener la disponibilidad de sus componentes. Usted puede incluso hacer que el «modelo compartido» un TableModel (aunque si es usado no sólo por la tabla, yo recomendaría al menos proporcionar una más amigable de la API de que no tenga fugas tabla abstracciones)

    Por otro lado, usted puede tener interfaces complejas para las actualizaciones (CustomerUpdateListener, OrderItemListener, OrderCancellationListener) y controlador dedicado (o mediador) sólo para la coordinación de los diferentes puntos de vista.

    Depende de lo complicado de su problema.

    • Alrededor del 90% de todos los puntos de vista consta de un cuadro donde el usuario puede seleccionar un elemento para editar. Lo que he hecho hasta ahora es que tengo un modelo de datos a través de la cual todas las operaciones CRUD va. Yo uso un TableModel para adaptar el modelo de datos para el JTable. Así, para actualizar un elemento que me gustaría invocar la tabla.llamado getmodel().llamado getmodel().actualización(Elemento e). En otras palabras, el JTable tipo de es el Controlador de ahora. Todas las acciones de los botones están colocados en clases separadas (i reutilizar en diferentes contextos) y hacer su trabajo a través de los métodos del modelo subyacente. Es que un diseño viable?
  5. 1

    Para la correcta separación, normalmente tendrían un controlador de clase de la clase de Marco sería delegado. Hay varias formas de establecer las relaciones entre las clases, puede implementar un controlador y se extienden con su vista principal de la clase, o el uso de un controlador independiente de la clase de que el Marco de llamadas cuando se producen eventos. La vista suele recibir eventos del controlador mediante la implementación de un oyente de la interfaz.

    A veces, una o más piezas del patrón MVC son triviales, o tan «fina» que añade una complejidad innecesaria separarlos. Si su controlador está llena de una línea de llamadas, tener en una clase separada que se puede acabar dejando en la oscuridad el comportamiento subyacente. Por ejemplo, si el en todos los eventos que se están manejando son relacionados a un TableModel y son fáciles de agregar y eliminar las operaciones que usted puede elegir para implementar la totalidad de la manipulación de la tabla de funciones dentro de ese modelo (así como las devoluciones de llamada necesario para que aparezca en el JTable). No es cierto MVC, pero se evita añadiendo complejidad, donde no es necesario.

    Sin embargo se implemente, recuerde JavaDoc sus clases, métodos y paquetes para que los componentes y sus relaciones están bien descrito!

    • mientras que la mayoría de su explicación es buena, tengo un problema con su asesoramiento en la combinación de los modelos con el controlador. ¿qué pasa si quiero cambiar de repente el controlador? ahora me encuentro con que has juntado el modelo con el controlador y la necesidad de modificar el modelo. el código ya no es extensible. sin embargo, corto su controlador, yo me cansaría combinar con un modelo. o una vista.
    • No me desacuerdo – depende mucho de la aplicación. Si su modelo no es más sofisticado que un objeto de la Lista, y el controlador no hace más que añadir y eliminar elementos, la creación de tres clases separadas (Lista modelo, Controlador y adaptador para su modelo de trabajo con el JTable) es excesiva. Es más fácil para refactorizar en el improbable caso de que usted necesita un controlador diferente, que para producir la laminilla de clases para el bien de algunos desconocidos necesidad futura.
    • de acuerdo, tal vez si usted está aplicación es pequeña, esta puede ser la manera más rápida. pero para la extensibilidad del sake (considerar si la suma no está hecha por el mismo programador), podría funcionar como una desventaja.
    • No sé cuánto tiempo usted ha estado en desarrollo de software, pero su publicación se demuestra que han abrazado el principio KISS. Demasiados inteligentes, pero sin experiencia a los desarrolladores de Java abrazo diseños patrones como son la biblia (patrones de diseño son poco más que de alto nivel de cortar y pegar de programación). En la mayoría de los casos, teniendo un enfoque purista por edificio separado de vista y controlador de las clases sólo sirve para hacer el mantenimiento por parte de cualquier otra persona que el desarrollador original en una pesadilla para los programas de más de un par de cientos de líneas de código. En caso de duda, Keep It Simple, Stupid!
    • Gracias por el complemento. A veces se siente que duro la experiencia ganada no es ningún partido para las personas que están decididos a ser «derecho».
    • El camino de la iluminación está plagado de baches, vendedores de aceite de serpiente, y la auto-justos. Sin embargo, no hay nada como tener a revolcarse en la propia defecación durante un período sostenido de tiempo para enseñarle a uno a mantener las cosas simples. No hay nada de malo con los patrones de diseño. Sin embargo, conocer los patrones de diseño no es lo mismo que saber de diseño de software. Ningún avance producto de software ha sido construido utilizando un libro de cocina de enfoque. El diseño de software de alto rendimiento que cumple con los requisitos y es fácil de mantener es todavía una forma de arte que requiere años para dominar.
    • Creo que otra razón importante para modelos, vistas y controladores de la capacidad de prueba.

  6. 0

    Si usted desarrolla un programa con un GUI, patrón mvc es casi allí, pero borrosa.

    Disecting modelo, vista y controlador de código es difícil, y normalmente no es sólo un refactorizar tarea.

    Usted sabe que usted tiene cuando el código es reutilizable. Si se han aplicado correctamente MVC, deben ser fáciles de implementar un TUI o un CLI o un RWD o un en primer móvil de diseño con la misma funcionalidad. Es fácil ver lo que hacen en realidad, además de un código existente.

    De hecho, las interacciones entre el modelo, la vista y el controlador sucede el uso de otros patrones de aislamiento (como Observador o el Oyente)

    Supongo que este post lo explica en detalle, de los directos sin patrón MVC (como usted lo hará en un Q&D) al final reutilizables aplicación:

    http://www.austintek.com/mvc/

Dejar respuesta

Please enter your comment!
Please enter your name here