?

Log in

No account? Create an account

flaMaster's journal

Шаблон Модель-Представление-Контроллер

Шаблон Модель-Представление-Контроллер

Previous Entry Поделиться Next Entry
kotik

SRC:
O’Rеillу. ActionScript 3.0 Design Patterns.
Глава 12. Model-View-Controller Pattern.

Начало.


Что такое шаблон Модель-Представление-Контроллер?

«Модель—Представление—Контроллер» (Model-View-Controller, MVC) — это составной шаблон, или несколько шаблонов, работающих совместно для реализации сложных приложений. Наиболее часто этот шаблон используется для создания интерфейсов приложений, и как следует из названия, состоит из трех элементов:

Модель (Model)
Содержит данные и логику приложения для управления состоянием этого приложения

Представление (View)
Реализует пользовательский интерфейс и состояние приложения, наблюдаемые на экране

Контроллер (Controller)
Обрабатывает действия пользователя, влияющие на состояние приложения.

Мощь шаблона MVC напрямую обуславливается разделением этих трех элементов с целью избежать пересечений зон ответственности каждого из них. Давайте посмотрим, за что отвечает каждый из элементов.


Модель

Модель отвечает за управление состоянием приложения. Логика приложения в модели представлена двумя важными задачами: модель отвечает на запросы относительно состояния приложения, и выполняет действия в ответ на запрос об изменении состояния.

Представление

Представление — это внешний облик приложения. Пользователь взаимодействует с приложением через Представление. Приложение может содержать несколько Представлений, которые могут быть как механизмом ввода, так и механизмом вывода. Например, в портативном цифровом плеере, таком как iPod, экран устройства будет Представлением. Кнопки плеера также считаются Представлением. Экран показывает название и продолжительность песни, изображение обложки альбома, и прочее, что соотносится с текущим состоянием устройства. Представление не обязательно должно быть видимым. В портативном плеере музыка, которая играет в наушниках, также является Представлением. Например, нажатие кнопки может вызвать некоторую слышимую ответную реакцию в виде щелчка в наушниках. Изменение громкости также отражается по каналу аудио-выхода. Слышимая ответная реакция связана с состоянием приложения.

Контроллер

Хотя термин Контроллер неявно подразумевает интерфейс, посредством которого управляется приложение, в шаблоне MVC Контроллер не содержит никаких элементов пользовательского интерфейса. Как говорилось выше, элементы пользовательского интерфейса, которые обеспечивают ввод, относятся к компоненту Представление. Контроллер же определяет, как Представления отзываются на ввод пользователя.

Допустим, наш цифровой плеер имеет кнопки Громче и Тише в Представлении. Громкость звука является переменной состояния. Модель будет отслеживать эту переменную, чтобы менять значение этой переменной в соответствии с логикой приложения. Если значение громкости звука проградуировать от 0 до 10, Контроллер определит, насколько нужно прибавить или убавить звук при одиночном нажатии на одну из этих кнопок. Поведение может сообщить Модели, что нужно увеличить громкость на 0,5 или на 0,1, или любое другое значение, как задано программно. В таком ключе, Контроллер — это специфичные реализации, которые определяют, каким образом приложение ответит на ввод пользователя.


Хотя каждый элемент в триаде MVC имеет отдельную и уникальную зону ответственности, они не функционируют в изоляции. На самом деле, с тем чтобы составить шаблон MVC, каждому элементу следует коммуницировать с остальными. Что это значит, мы рассмотрим ниже.


Взаимодействие элементов MVC

Каждый элемент в шаблоне MVC общается с остальными весьма специфичными способами. Коммуницирование реализуется последовательностью событий, которые обычно запускаются взаимодействием пользователя с приложением. Последовательность событий выглядит так:
  1. Пользователь взаимодействует с элементом интерфейса (например, нажимает на кнопку в Представлении).
  2. Представление отсылает событие нажатия Контроллеру, чтобы решить, как это нажатие обработать.
  3. Контроллер меняет Модель на основе того, что он решил относительно нажатия кнопки.
  4. Модель информирует Представление о том, что состояние Модели изменилось.
  5. Представление читает информацию о состоянии в Модели и самостоятельно видоизменяется.



Рисунок 12-1. Направления коммуницирования между элементами MVC

Это очень простая схема того, как взаимодействуют элементы MVC. В некоторых случаях Контроллер может просто указать Представлению чтобы оно изменилось. Это единственный случай, когда изменения в Представлении становятся необходимыми из-за действий пользователя и не требуют изменений в Модели, а просто приводят к одним только визуальным изменениям. Например, вспомните о том, как пользователь выбирает песню на цифровом плеере. Он выбирает песню из списка кнопками прокрутки. Представление должно сообщить Контроллеру, что нажаты кнопки Листать вверх или Листать вниз, но Контроллеру не нужно информировать об этом Модель. Он напрямую говорит Представлению прокрутить список песен в нужном направлении. Такое действие пользователя не требует изменений в Модели. Однако, когда пользователь выберет песню из списка и запустит её на воспроизведение, Контроллер изменит Модель, чтобы отразить это изменение в значении воспроизводимой в данный момент песни.

Кроме того, изменения в Модели не всегда инициируются действиями пользователя. Модель может обновиться сама, основываясь на неких событиях. Возьмем, например, индикатор стоимости акций. Модель не связана с текущей стоимостью акций. Однако, стоимость сама по себе меняется, и Модель может установить таймер, чтобы периодически получать обновленные данные от веб-сервиса. И тогда, всякий раз, как только Модель обновит свои данные о стоимости акций, она проинформирует Представление о том, что состояние изменилось.

Другой особенностью шаблона MVC является то, что каждая такая Модель может иметь более одного Представления, ассоциированного с ней. Например, в нашем портативном плеере установки громкости могут быть отображены на дисплее с помощью индикатора уровня. А кроме того, уровень звука на аудио-выходе соотносится с громкостью звука в наушниках. И дисплей, и звук в наушниках являются Представлениями состояния устройства.

Взгляните на Рисунок 12-1 и обратите внимание на направление стрелок. Они показывают, кто инициирует взаимодействие между элементами. Для того, чтобы один MVC-элемент смог сообщаться с другим, ему нужно знать о нем и владеть ссылкой на этот элемент.

Думайте о Модели, Представлении и Контроллере как о трех разных классах. Давайте посмотрим, каким классам нужно иметь ссылки на остальные классы:

Модель
Ей нужно иметь ссылку на Представление

Представление
Ему нужно иметь ссылку и на Модель, и на Контроллер

Контроллер
Ему необходимо владеть ссылкой на Модель

Мы начали с того что заявили, что MVC – это составной шаблон, который объединяет несколько шаблонов. Вам, должно быть, интересно, какие шаблоны вошли в данный составной шаблон. Или, точнее, чем они могут быть представлены? Главным преимуществом использования шаблона MVC является возможность разъединять его на составляющие три элемента. Это позволяет нам увязать несколько Представлений с одной Моделью, заменять Модели и Контроллеры, не затрагивая другие элементы. Но некоторые элементы в триаде MVC должны поддерживать ссылки на остальные элементы, а также поддерживать активный обмен данными между ними. Как мы можем назвать такое разделение? Это имеет отношение к паттернам Observer (Обозреватель), Strategy (Стратегия) и Composite (Компоновщик).


Внедрение шаблонов в MVC

Как мы уже рассмотрели, Модель может быть ассоциирована с несколькими Представлениями. В MVC Модели нужно информировать все связанные с ней Представления о происходящих изменениях. К тому же, это нужно делать без знания специфичных подробностей относительно Представлений, и даже без информации о том, скольким Представлениям следует измениться. Эта задача лучше всего решается применением реализации шаблона Обозреватель (см. Главу 8).

Каждая Модель может иметь несколько Представлений, с ней связанных. Так же, Представления могут быть сложными, с несколькими окнами или панелями, внутри которых находятся другие элементы пользовательского интерфейса. Например, такие элементы интерфейса как кнопки, текстовые поля, списки, ползунки и т.п. могут быть сгруппированы в панель с закладками, а панель в свою очередь может быть частью окна наравне с другими панелями. Каждая кнопка или группа кнопок может быть Представлением. То же самое с коллекцией текстовых полей. Представляется полезным обращаться с панелью или окошком, которые содержат коллекции простых Представлений, таким же образом, как мы обращаемся с любыми другими Представлениями. Именно здесь использование шаблона Компоновщик сэкономит нам много сил (см. Главу 6). Почему реализация шаблона Компоновщик столь полезна в данном контексте? Если Представления могут быть вложенными, а они таковы, если созданы с применением шаблона Компоновщик, процесс обновления упрощается. Событие обновления автоматически обойдет все потомственные Представления. Создание сложных Представлений становится проще, когда нет необходимости рассылать индивидуальные сообщения об обновлении каждому вложенному Представлению.

Представления ограничивают свою деятельность лишь внешним представлением состояния Модели. Они передают события пользовательского интерфейса Контроллеру. Поэтому, Контроллер – это в большей степени алгоритм того, как обработать пользовательский ввод в конкретном Представлении. Такое делегирование инкапсулирует реализацию того как конкретный элемент пользовательского элемента ведет себя в условиях изменения Модели. Мы может довольно просто заменить один Контроллер для одного и того же Представления, чтобы получить другое поведение. Это идеальный контекст для реализации щаблона Стратегия.

Далее мы рассмотрим, как эти шаблоны реализованы в MVC, на примере разработки минималистичного примера.


Минималистичный пример шаблона MVC

Этот простой пример отслеживает нажатия клавиш. Когда нажимается очередная клавиша, это приводит к изменению Модели и информированию Представления о необходимости обновиться. Представление задействует стандартное окно вывода Output во Flash, чтобы поместить туда код символа, который ввел пользователь. Код символа — это числовое значение символа в кодовой таблице текущей раскладки. Этот пример объясняет, каким образом шаблоны Обозреватель, Стратегия и Компоновщик интегрированы в MVC.


Модель как Конкретный Субьект в шаблоне Обозреватель

Взаимоотношения между Моделью и Представлением — это связь между Субъектом и Обозревателем (См. Главу 8). Модель должна реализовать интерфейс Субъекта, который является частью шаблона Обозреватель. К счастью, ActionScript 3.0 имеет встроенные классы, уже реализующие этот принцип, используя модель событий ActionScript чтобы информировать Обозревателей об изменениях.

Класс EventDispatcher в ActionScript 3.0

Класс EventDispatcher снабжен интерфейсом IEventDispatcher. Наравне с другими методами, интерфейс IEventDispatcher определяет следующие методы, необходимые для субъекта в шаблоне Обозреватель. (См. документацию по AS3 для подробной информации о всех параметрах методов).

addEventListener(type:String,
   listener:Function,
   useCapture:Boolean = false,
   priority:int = 0,
   useWeakReference:Boolean = false):void
 
removeEventListener(type:String,
   listener:Function,
   useCapture:Boolean = false):void
 
dispatchEvent(event:Event):Boolean


Чтобы Модель могла выступить в качестве Конкретного Субъекта в шаблоне Обозреватель, необходимо реализовать интерфейс IEventDispatcher. Однако, самый простой способ для определенного пользовательского класса заполучить способность распространять события – это наследовать от класса EventDispatcher.

Обозреватель регистрирует методы слушателя, чтобы получать уведомлении от объектов EventDispatcher, методом addEventListener( ).

Модель

Наша Модель сохраняет код символа, соответствующий нажатой клавише, в свойстве. Необходимо реализовать сеттер и геттер, чтобы стало возможным Представлению и Контроллеру получить доступ к этому свойству и изменять его. Давайте определим интерфейс для нашей Модели (Пример 12-1).

Пример 12-1. IModel.as

package {
   import flash.events.*;
 
   public interface IModel extends IEventDispatcher {
      function setKey(key:uint):void;
      function getKey():uint;
   }
}


Интерфейс IModel, показанный в Примере 12-1, расширяет интерфейс IEventDispatcher и определяет пару методов для прочтения и установки кода символа последней нажатой клавиши. Поскольку интерфейс IModel расширяет IEventDispatcher, любой класс, реализующий его, должен реализовать все методы, определенные в обоих интерфейсах. Класс Model, показанный в Примере 12-2, реализует интерфейс IModel.

Пример 12-2. Model.as

package {
   import flash.events.*;
 
   public class Model extends EventDispatcher implements IModel {
 
      private var lastKeyPressed:uint=0;
 
      public function setKey(key:uint):void {
         this.lastKeyPressed=key;
         dispatchEvent(new Event(Event.CHANGE)); // распространяется событие
      }
 
      public function getKey():uint {
         return lastKeyPressed;
      }
   }
}


Класс Model расширяет класс EventDispatcher, который уже реализовал интерфейс IEventDispatcher. Обратите внимание, что функция dispatchEvent() вызывается внутри метода setKey(). Она отсылает событие CHANGE всем зарегистрированным обозревателям, как только значение lastKeyPressed изменится внутри метода setKey().


Контроллер как Конкретная Стратегия в шаблоне Стратегия.

Отношения между Контроллером и Представлением можно представить как стратегию и контекст в шаблоне Стратегия. Каждый Контроллер будет конкретной стратегией, реализующей требуемое поведение в рамках интерфейса Стратегии.


Контроллер

В нашем минималистичном примере поведение, требуемое от Контроллера, это всего лишь принятие события о нажатии клавиши. IKeyboardInputHandler — это интерфейс Стратегии (Пример 12-3), где определен единственный метод keyPressHandler( ).

Пример 12-3. IKeyboardInputHandler.as

package {
   import flash.events.*;
 
   public interface IKeyboardInputHandler {
      function keyPressHandler(event:KeyboardEvent):void;
   }
}


Конкретным Контроллером будет класс Controller (Пример 12-4), который реализует интерфейс IKeyboardInputHandler.

Пример 12-4. Controller.as

package {
   import flash.events.*;
 
   public class Controller implements IKeyboardInputHandler {
 
      private var model:IModel;
 
      public function Controller(aModel:IModel) {
         this.model=aModel;
      }
 
      public function keyPressHandler(event:KeyboardEvent):void {
         model.setKey(event.charCode); // изменяем модель
      }
   }
}


Обратите внимание, что Контроллер имеет конструктор, который в качестве параметра принимает экземпляр Модели. Это необходимо для того, чтобы Контроллер смог установить связь с Моделью, как это показано на Рисунке 12-1. Поэтому необходимо хранить ссылку на Модель.

Метод keyPressHandler( ) принимает событие пользовательского интерфейса (в данном случае KeyboardEvent) как параметр, и потом решает как его обработать. В нашем примере он просто устанавливает код нажатой клавиши в Модели.


Представление как Конкретный Обозреватель в шаблоне Обозреватель и Контекст в шаблоне Стратегия

Представление, возможно, наиболее сложный элемент в шаблоне MVC. Он играет роль интегрирующей части в реализации шаблонов как Обозревателя, так и Стратегии, что формирует основу его взаимоотношения с Моделью и Контроллером. Класс View, показанный в Примере 12-5, реализует Представление в минималистичном примере.

Пример 12-5. View.as

package {
   import flash.events.*;
   import flash.display.*;
 
   public class View {
 
      private var model:IModel;
 
      private var controller:IKeyboardInputHandler;
 
      public function View(aModel:IModel,oController:IKeyboardInputHandler,target:Stage) {
         this.model=aModel;
         this.controller=oController;
 
         // подписывается на получение уведомлений от Модели
         model.addEventListener(Event.CHANGE,this.update);
 
         // подписывается на получение нажатий клавиш от сцены
         target.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyPress);
 
      }
 
      private function update(event:Event):void {
         // получение данных от Модели и обновление Представления
         trace(model.getKey());
      }
 
      private function onKeyPress(event:KeyboardEvent):void {
         // обработка передается в Контроллер (Стратегия) на обработку
         controller.keyPressHandler(event);
      }
   }
}



Представление нуждается в ссылках на Модель и на Контроллер для взаимодействия с ними, как показано на Рисунке 12-1. И экземпляр Модели, и экземпляр Контроллера передаются Представлению в его конструкторе. К тому же, Представление в нашем примере нуждается в ссылке на сцену (Stage), чтобы зарегистрировать себя как получателя событий нажатия клавиш.

Кроме того что класс View рисует пользовательский интерфейс, он выполняет еще пару важных задач. Он регистрируется у Модели для получения событий об обновлении, и делегирует Контроллеру обработку ввода пользователя. В нашем примере Представление не имеет внешнего видимого присутствия на сцене, но отображает состояние Модели в окне вывода Output. Ему нуждается в получении события нажатия клавиши, и регистрирует метод onKeyPress( ) для получения события KEY_DOWN от сцены. Вторая задача – это зарегистрировать метод слушателя update( ) для получения события CHANGE от модели. При получении уведомления об изменении, метод update() прочитывает код последней нажатой клавиши из Модели и печатает его в окне вывода, используя функцию trace().


Построение триады MVC

Мы рассмотрели реализацию каждой из трех составляющих шаблон MVC частей по отдельности. Однако, должен существовать клиент, который инициализирует каждый элемент и построит модель MVC. На самом деле, никакого сложного построения не будет — все что нужно уже сделано при написании классов Модели, Представления и Контроллера. В Примере 12-6 приводится класс Flash-документа, который иллюстрирует элементы MVC.

Пример 12-6. Main.as (основной класс минималистичного примера)

package {
 
   import flash.display.*;
   import flash.events.*;
 
   /**
   * Main Class
   * @ purpose: Document class for movie
   */
 
   public class Main extends Sprite {
 
      public function Main() {
         var model:IModel=new Model  ;
         var controller:IKeyboardInputHandler=new Controller(model);
         var view:View=new View(model,controller,this.stage);
      }
   }
}


После того как Модель, Контроллер и Представление инициализированы, они установят связь друг с другом и начнут работать. Нажатие клавиши на клавиатуре приведет к выводу кода соответствующего символа в окне Output.

Вам нужно запретить шорткаты для тестирования нажатий клавиш. В противном случае пользовательский интерфейс Flash перехватит события нажатия клавиш, которые соответствуют шорткатам. Чтобы запретить шорткаты, выберите Disable Keyboard Shortcuts из меню Control во время выполнения ролика.

Обратите внимание, что экземпляр Модели передается Контроллеру. Подобным образом экземпляры Модели и Контроллера передаются Представлению. Мы можем просто заместить существующие Модель и Контроллер другими, при условии, что они реализуют интерфейсы IModel и IKeyboardInputHandler. Дополнительные Представления также могут быть безболезненно добавлены прямо в отношения Субъект-Обозреватель между Моделью и Представлением. Модель ничего не знает о Представлениях, так как это забота Представления — зарегистрировать себя в качестве слушателя уведомлений об изменении Модели. Это большой плюс шаблона MVC; Модель, Представление и Контроллер разделены, слабо связаны, что придает гибкости в их использовании.


Вложенные Представления и узлы шаблона Компоновщик

Как вы помните, Представление, возможно, самый сложный элемент в триаде MVC, поскольку в контексте MVC он задействован как в реализации шаблона Обозреватель, так и в Стратегии. Наши элементы Представления способны быть более сложными, поскольку могут реализовать третий шаблон — Компоновщик (см. примеры шаблона Компоновщик в Главе 6). Реализация Представлений как элементов шаблона Компоновщик позволяет разобраться со сложными пользовательскими интерфейсами, которые содержат множественные Представления. Вложение Представлений превносит некоторые преимущества в процесс обновления пользовательского интерфейса, так как обновления могут распространяться по ветвям структурного дерева составного Представления. Также составные Представления могут добавлять и удалять вложенные Представления, основываясь на режиме работы приложения и пользовательских настройках. Хорошим примером сложного интерфейса является панель Properties Inspector в среде разработки Flash. Содержимое Properties Inspector зависит от контекста, и элементы интерфейса появляются и исчезают в зависимости от того, какой объект выделен на сцене.


Компонент и составное Представление

Первым шагом будет создание компонента и составных классов для Представления. Эти классы должны быть описаны как абстрактные, должны быть подклассами и не должны порождать экземпляры, как показано в Примере 12-7.

Пример 12-7. ComponentView.as

package {
 
   import flash.errors.IllegalOperationError;
   import flash.events.Event;
   import flash.display.Sprite;
 
   // АБСТРАКТНЫЙ класс (от него нужно наследовать, не создавая экземпляра данного класса)
   public class ComponentView extends Sprite {
      {
 
         protected var model:Object;
         protected var controller:Object;
 
         public function ComponentView(aModel:Object,aController:Object=null) {
            this.model=aModel;
            this.controller=aController;
         }
 
         public function add(c:ComponentView):void {
            throw new IllegalOperationError("add operation not supported");
         }
 
         public function remove(c:ComponentView):void {
            throw new IllegalOperationError("remove operation not supported");
         }
 
         public function getChild(n:int):ComponentView {
            throw new IllegalOperationError("getChild operation not supported");
            return null;
         }
 
         // АБСТРАКТНЫЙ метод(должен быть замещен в классе-потомке)
         public function update(event:Event=null):void {
         }
 
      }
   }
}


Класс ComponentView из Примера 12-7 определяет абстрактный интерфейс для Представления компонента. Это похоже на класс классического компонента из Главы 6, но с несколькими ключевыми отличиями. Класс ComponentView хранит ссылку на Модель и Представление, и содержит конструктор. Не все Представления обрабатывают ввод пользователя, и компонентное Представление может быть сконструировано с простой передачей экземпляра Модели. Поэтому параметр aController принимает в конструкторе значение null по умолчанию. Также обратите внимание, что класс ComponentView унаследован от класса Sprite. Это логично, поскольку большинство Представлений рисуют пользовательский интерфейс на сцене. Мы можем использовать свойства и методы, реализованные в классе Sprite, для рисования и добавления объектов в список отображения.

Метод update( ) должен вести себя как абстрактный метод. Дочерние Представления, являющиеся потомками ComponentView, должны заместить и реализовать метод update( ), чтобы уметь обновлять свою часть пользовательского интерфейса. По этой причине методу передается параметр типа Event. Этот параметр также по умолчанию установлен в null, что позволяет вызывать update() без передачи события как параметра. Такой подход полезен, когда изначально отрисованный пользовательский интерфейс находится в своем состоянии по умолчанию, и наш следующий пример иллюстрирует это.

Класс CompositeView расширяет ComponentView и замещает методы, которые отвечают за дочерние Представления.

Пример 12-8. CompositeView.as

package {
 
   import flash.events.Event;
 
   // АБСТРАКТНЫЙ класс (от него нужно наследовать, не создавая экземпляра данного класса)
   public class CompositeView extends ComponentView {
 
      private var aChildren:Array;
 
      public function CompositeView(aModel:Object,aController:Object=null) {
         super(aModel,aController);
         this.aChildren=new Array  ;
      }
 
      override public  function add(c:ComponentView):void {
 
         aChildren.push(c);
      }
 
      override public  function update(event:Event=null):void {
         for each (var c:ComponentView in aChildren) {
            c.update(event);
         }
      }
 
   }
}


Обратите внимание на замещаемую (override) функцию update( ) класса CompositeView в Примере 12-8. Она вызывает метод update у всех дочерних классов. Поэтому, вызов функции update() в корне структуры составного Представления приведет к распространению обновления по структуре и обойдет дерево компонента, обновляя все Представления. Давайте расширим классы CompositeView и ComponentView, и создадим структуру Представлений, чтобы посмотреть как это работает



Продолжение



  • а ссылку на оргинальную книжку можно ;) ?
  • мега спасибо !
  • Модель
    Ей нужно иметь ссылку на Представление

    Представление
    Ему нужно иметь ссылку и на Модель, и на Контроллер

    Контроллер
    Ему необходимо владеть ссылкой на Модель


    просто ни в какие ворота не соответствует правде... хотя до этих слов всё было верно...
    • «Model
      Needs to have a reference to views

      View
      Needs references to both the model and controller

      Controller
      Needs a reference to the model»


      Я неправильно перевел, или вы не согласны с автором?
      • Сначала подумал, что ошибка перевода...
        автор имеет ввиду под reference чисто логическую связь, потому что "нужно иметь ссылку на представление" и "нужно иметь связь с представлениями" (скорее так переводится) в MVC две большие разницы...

        Но перечитав увидел строчку
        Для того, чтобы один MVC-элемент смог сообщаться с другим, ему нужно знать о нем и владеть ссылкой на этот элемент.
        Если автор и правда так пишет, то значит нарочно вводит читателя в заблуждение...

        1)модель не держит ссылок на представление и контроллер и потому абсолютно от них не зависит.
        Но имеет свзяь с представлениями по шаблону обсервер. В некоторых случаях (типа .NET) шаблон напрямую поддерживается средой и языками (события\делегаты), в других нужно вручную реализовывать.

        2)Паттерн призван, в том числе, гарантировать валидное отображение модели. Поэтому вложенные view имхо не самый удачный вариант, хотя наверно имеет место быть, когда событий модель генерит много и подписка\отписка затратна... Просто обычно view либо разные, либо нет...

        3)Представление может не иметь ссылку на модель. Это называется модель проталкивания, когда вся инфа приходит подписчику в аргументах. Например если вид это диаграмма, сложно отслеживать какие диаграммы с какими моделями связаны...

        4)паттерн никак не регламентирует как общаться представлению и контроллеру. Это может быть жёсткая ссылка или ссылка на интерфейс, который не раскрывает все возможности поведения, а только нужные данному view. Зачастую, взаимодействует с помощью паттерна команда (как раз сейчас продумываю дизайн кой-чего), а может и получать эту ссылку из какого-нить синглтона ControllerManager-а (ведь не только вид, но и поведение может меняться).
        • Да, имеет место мой косяк. Надо будет подредактировать.

          Насчет п.3. Проталкивание — это, наверное, неплохо, но уж как-то выглядит некрасиво. Модель либо должна точно знать куда чего проталкивать (а это уже логика, свойственная больше контроллеру), либо рассылать месседжи всем подряд (а это ненужная избыточность).

          Автор рассматривает классическую схему, и понятно, что в чистом виде ее использовать не всегда получается. У меня, например, в одном проекте модель занимается еще и загрузкой данных без выделения этой функции в отдельный прокси, хотя можно сказать, что это и есть прокси, который рассылает уведомления и выполняет функции модели. И ничего, все четко пашет.
          • ну в модель логику конечно ни к чему запихивать... ну например изменилось св-во, модель уведомляет подписчиков св-во "Name" изменилось. В модели проталкивания это может выглядить так: я модель такая-то, моё св-во "Name" изменилось.

            Ты уверен, что правильно понимаешь паттерн обсервер (aka издатель\подписчик)?
            рассылать мессаджи всем подряд она никак не может, потому что подписываются на события view и если они подписались, то значит зависят от этого события, лишней рассылки тут быть не может... похоже у тебя модель имеет ссылку на вью...
            • я как-то на 'ты' сразу... ничего что так?
              • все нормально.

                модель у меня не имеет ссылки на вью, и разумеется, вью подписалось на события модели. Я имел в виду ситуацию, когда модель, допустим, изменилась существенно, и тогда придется рассылать каждой части вью отдельный кусок модели вместо того чтобы разослать всем одно событие апдейта чтобы каждая часть вью прочитала нужный ей кусок.
                • ну могет быть, могет быть... сейчас всё могет быть... открылся новый бар неподалёку... ик... =)
                  • pureMVC Model question

                    привет, осваиваю сабж.
                    разве не логично в ситации, когда идет подгтовка к запуску приложения и происходит следующее:
                    1. получаем XML c путями к ресурсам, опрос system lng, sharedObj.
                    2. получаем CSS, embededFonts_swf,assets. Имея из п.1 пути, зная lng, имея юзер инфо -повторно, был, есть мессаджи и т.п.

                    все это уместить в одном proxy классе, и только когда все это сделано послать сообщение о Старnапе приложения. Есть, один нюанс наверно -известсить View, о показе прелоадера общего.

                    Или все же быть строгим и под каждую загрузку отдельный прокси класс писать? Или и мелкую логику решения что грузить в заdисимоти от lang системы, данных sharedObj тоже отдавать Controller?
  • "Модель
    Ей нужно иметь ссылку на Представление"

    Модель ничего не знает о представлении и ей все равно есть ли представление или нет.
  • Meet your perfect lover and Be Naughty today! Go Here dld.bz/chwZQ
Разработано LiveJournal.com