Архитектура

Проектирование компьютерных программ

История

Польза

Главная польза каждого отдельного шаблона состоит в том, что он описывает решение целого класса абстрактных проблем. Также тот факт, что каждый шаблон имеет свое имя, облегчает дискуссию об абстрактных структурах данных (ADT) между разработчиками, так как они могут ссылаться на известные шаблоны. Таким образом, за счёт шаблонов производится унификация терминологии, названий модулей и элементов проекта.

Правильно сформулированный паттерн проектирования позволяет, отыскав удачное решение, пользоваться им снова и снова.

В отличие от идиом, шаблоны независимы от применяемого языка программирования.

Критика

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

Нередко шаблонами заменяется отсутствие или недостаточность документации в сложной программной среде.

Есть мнение, что слепое применение шаблонов из справочника, без осмысления причин и предпосылок выделения каждого отдельного шаблона, замедляет профессиональный рост программиста, так как подменяет творческую работу механическим подставлением шаблонов. Люди, придерживающиеся данного мнения, считают, что знакомиться со списками шаблонов надо тогда, когда «дорос» до них в профессиональном плане - и не раньше. Хороший критерий нужной степени профессионализма - выделение шаблонов самостоятельно, на основании собственного опыта. При этом, разумеется, знакомство с теорией, связанной с шаблонами, полезно на любом уровне профессионализма и направляет развитие программиста в правильную сторону. Сомнению подвергается только использование шаблонов «по справочнику».

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

Для преодоления этих недостатков используется рефакторинг .

Основные типы шаблонов проектирования

Основные шаблоны (Fundamental)

• Marker interface
• Property Container

Порождающие шаблоны проектирования

• Factory Method/Фабричный метод , Virtual Constructor
• Anonymous subroutine objects

Структурные шаблоны (Structural)

• Proxy/Заместитель , Surrogate
• Container
• Extensibility
• Pipes and filters
• Private class data

Поведенческие шаблоны (Behavioral)

Шаблоны параллельного программирования (Concurrency)

• Active Object
• Balking
• Guarded suspension
• Half-Sync/Half-Async
• Leaders/followers
• Monitor Object
• Reactor
• Read write lock
• Scheduler
• Thread pool
• Thread-Specific Storage
• Single Thread Execution

MVC

• Enterprise

  Unsorted

  • Property Container
  • Event Channel
  • Repository/Хранилище

  Другие типы шаблонов

  Также на сегодняшний день существует ряд других шаблонов:

  • Carrier Rider Mapper, предоставление доступа к хранимой информации
  • аналитические шаблоны, описывают основной подход для составления требований для программного обеспечения (requirement analysis) до начала самого процесса программной разработки
  • коммуникационные шаблоны, описывают процесс общения между отдельными участниками/сотрудниками организации
  • организационные шаблоны, описывают организационную иерархию предприятия/фирмы
  • Анти-паттерны (Anti-Design-Patterns) описывают как не следует поступать при разработке программ, показывая характерные ошибки в дизайне и в реализации.

  См. также

  • Обобщённое программирование

  Ссылки

  • Ольга Дубина Обзор паттернов проектирования . - Обзор нескольких наиболее значительных монографий, посвященных паттернам проектирования информационных систем. Проверено 5 сентября 2006.
  • Portland Pattern Repository - список шаблонов проектирования на движке вики
  • mgrand’s book - сайт с описанием большого количества шаблонов проектирования
  • Resign Patterns - проломы проектно-дизориентированного проектирования (пародия на паттерны)
  • Eclipse’s Culture of Shipping (англ.) Erich Gamma

  Литература

  • Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес Приемы объектно-ориентированного проектирования. Паттерны проектирования = Design Patterns: Elements of Reusable Object-Oriented Software. - СПб: «Питер» , 2007. - С. 366. - ISBN 978-5-469-01136-1 (также ISBN 5-272-00355-1)
  • Крэг Ларман Применение UML 2.0 и шаблонов проектирования = Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development. - М.: «Вильямс» , 2006. - С. 736. - ISBN 0-13-148906-2
  • Мартин Фаулер Архитектура корпоративных программных приложений = Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series). - М.: «Вильямс» , 2007. - С. 544. - ISBN 0-321-12742-0
  • Джошуа Кериевски Рефакторинг с использованием шаблонов (паттернов проектирования) = Refactoring to Patterns (Addison-Wesley Signature Series). - М.: «Вильямс» , 2006. - С. 400. - ISBN 0-321-21335-1
  • Скотт В. Эмблер, Прамодкумар Дж. Садаладж Рефакторинг баз данных: эволюционное проектирование = Refactoring Databases: Evolutionary Database Design (Addison-Wesley Signature Series). - М.: «Вильямс» , 2007. - С. 368. - ISBN 0-321-29353-3

  Wikimedia Foundation . 2010 .

• Паттерсон, Джемс
• Паттерсон, Персиваль

Смотреть что такое "Паттерны проектирования" в других словарях:

Шаблон проектирования - У этого термина существуют и другие значения, см. Паттерн. В разработке программного обеспечения, шаблон проектирования или паттерн (англ. design pattern) повторимая архитектурная конструкция, представляющая собой решение проблемы… … Википедия

Шаблоны проектирования - (паттерн, англ. design pattern) это многократно применяемая архитектурная конструкция, предоставляющая решение общей проблемы проектирования в рамках конкретного контекста и описывающая значимость этого решения. Паттерн не является законченным… … Википедия

Шаблоны проектирования GRASP - GRASP (англ. General Responsibility Assignment Software Patterns (общие образцы распределения обязанностей)) паттерны, используемые в объектно ориентированном проектировании для решения общих задач по назначению обязанностей классам и объектам. В … Википедия

Материал статьи для уровня Beginners. Здесь не будет Moose, только чистый Perl. Предполагается, что какое-то ООП в Perl уже знакомо

Паттерны это стандартные приемы, решающие небольшую конкретную задачу. Это не инструкция, как писать код, а схема или принцип организации кода, модулей и т. п. Уверена, что если вы их не знаете на уровне диаграмм UML, то встречали в коде. Этот небольшой обзор познакомит с самыми простыми, полезными и часто используемыми паттернами.

Singleton (Одиночка)

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

Реализация

Пусть у нас будет какой-то абстрактный класс с именем MyClass .

Package MyClass; use strict; our $singleton = undef; sub new { my $class = shift; return $singleton if defined $singleton; my $self = {}; $singleton = bless($self, $class); $singleton->init(); return $singleton; } # other methods sub init { #... } 1;

$singleton->init(); - вот тут, к примеру, проводится какая-то инициализация (либо она может быть отложена до вызова конкретных функций).

Пример использования

use MyClass; use strict; sub f { print MyClass->new()->{name}, "\n"; } sub f2 { print MyClass->new()->{name}, "\n"; } my $obj = MyClass->new(); $obj->{name} = "Bob"; # это не ООП! f(); f2(); $obj->{name} = "Mike"; # и это тоже f(); f2();

На выходе

Bob Bob Mike Mike

В результате вызова функций f() и f2() мы получим один и тот же созданный объект, ссылка на который хранится у нас в $MyClass::singleton , с ней можно работать напрямую, но это моветон и делать так не надо (за исключением ситуаций, когда требуется высокая производительность, а использование аксессоров создаёт ощутимые накладные расходы).

Таким образом, можно в любом месте кода создавать объект через конструктор и не волноваться, что он каждый раз будет создаваться заново.

На CPAN, кстати, есть Class::Singleton , MooseX::Singleton , Apache::Singleton и еще куча других.

Abstract Factory (Абстрактная фабрика)

Порождающий паттерн. Берет на себя ответственность за создание объекта нужного класса. Мы просто обращаемся к ее конструктору, а какой нам вернуть объект, фабрика решает сама. Создаваемые объекты, конечно, должны быть из одного семейства и иметь идентичный интерфейс. То есть, они должны быть взаимозаменяемыми.

В качестве примеров использования: в номере 21 в статье паттерн использован для создания объекта-логгера в зависимости от способа вывода: либо stderr, либо file. В более бизнесовом мире встречаются разные способы доставки (там все одинаковое, но разные формочки, разные коэффициенты какие-нибудь), разные форматы прайсов от поставщиков (у кого-то Excel, у кого-то XML), разные способы отправки уведомлений (e-mail, SMS).

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

Пример использования

use AnimalFactory; my $animal_one = AnimalFactory->new(legs => 2); print ref $animal_one, "\n"; my $animal_two = AnimalFactory->new(legs => 4); print ref $animal_two, "\n"; $animal_one->walk(); $animal_two->walk();

На выходе

Chicken Cow

Реализация

package AnimalFactory; use Chicken; use Cow; sub new { my $class = shift; my $opt = {@_}; return Cow->new() if $opt->{legs} == 4; return Chicken->new() if $opt->{legs} == 2; } 1;

Тут важно понимать, что обращаясь к конструктору AnimalFactory, мы получаем объект класса вовсе не AnimalFactory, а того, который она решит создать.

Если нам понадобится класс Snake , то мы просто добавим логику его создания в AnimalFactory , как-нибудь так:

Return Snake->new() if $opt->{legs} == 0;

Если вдруг Cow нужно будет заменить на Horse , это нужно будет сделать только в одном месте - в AnimalFactory , не затрагивая других участков кода.

Абстрактную фабрику стоит использовать там, где класс объекта зависит от каких-нибудь внешних факторов: пользовательских настроек, версии браузера, ОС и т. п.

(В некоторых случаях не очень хорошо, что мы подгружаем все возможные классы сразу через use , это можно изменить: внести внутрь конструктора и подключать классы через require уже после анализа параметров и до создания конкретного объекта.)

Template Method (Шаблонный метод)

Паттерн поведения. Паттерн используется для определения основного алгоритма для всех подклассов. Берем алгоритм, делим его на много мелких этапов, пишем в базовом классе, а все подклассы реализуют различающиеся части.

Самый простой пример: импорт товаров от поставщика. Нужно распарсить файл, пройти по всем товарам от поставщика, если товар найден - обновить его, если не найден - создать, подсчитать конечную стоимость, записать операцию с товаром в журнал, проделать что-нибудь еще с чем-нибудь.

Использование

my $import = ImportFactory->new(type => "Bekka"); $import->do;

(Здесь я использую фабрику для создания нужного мне объекта по имени поставщика, от которого загружается файл.)

Но можно обойтись и без фабрики, а сделать вот так (хотя гибкость это явно снижает, но она и не всегда такая нужна):

My $type = "Bekka"; my $import = $type->new(); $import->do;

Реализация

Допустим, у меня тут два поставщика: Bekka

Package Bekka; use base "Import"; sub parse { # parse Excel } sub count_price { # price * 2 } 1;

который присылает файлы в Excel, и у которого цену из файла нужно увеличивать в два раза.

И Pukka , у которого файлы в XML, а цену нужно делить пополам:

Package Pukka; use base "Import"; sub parse { # parse XML } sub count_price { # price / 2 } 1;

Оба эти класса имеют родителя Import , который и описывает основной алгоритм загрузки файла (sub do). В нем определяются все используемые методы, но работающие по какому-то умолчанию. (У методов, конечно, еще есть какой-нибудь код, но здесь он не нужен, поэтому его не привожу.)

Package Import; ... sub do { my $self = shift; $self->parse(); while ($self->next) { if ($self->find) { $self->update; } else { $self->insert; } $self->count_price; $self->log; } $self->finish; } sub next; sub find; sub update; sub insert; sub count_price { my $self = shift; # use original price } 1;

Получается: фабрика создает нам объект нужного класса, основываясь на имени поставщика. Базовый объект для него описывает весь процесс импорта товара от любого поставщика. Объект конкретного класса переопределяет те методы, которые ему не подходят, на свою реализацию - в нашем случае методы count_price и parse .

Метод do из класса Import и есть наш шаблонный метод - он описывает шаблон поведения. И вовсе необязательно, что он должен его реализовывать. В реальности сложно найти задачи такого плана, которые могут быть удовлетворены поведением по умолчанию.

Удобно использовать констукцию can для методов, которые не обязательно должны быть в базовом классе, но могут быть в подклассах: $self->do_smth if $self->can("do_smth") , тогда метод будет вызваться только в том случае, если он реально определен. Это избавит от кучи пустого кода, а также позволяет писать довольно удобно хуки, типа:

$self->before_update() if $self->can("before_update"); $self->update(); $self->after_update() if $self->can("after_update");

Strategy (Стратегия)

Паттерн поведения. Другое название - Политика. Используется для взаимозаменяемости алгоритмов или их фрагментов. Например, когда у нас есть разные способы расчета скидки на заказ. (Пример высосан из пальца, и для таких случаев делать подобные схемы - роскошь. Но он прост и понятен.)

Использование

use DiscountFactory; use Order; my $order = Order->new(); $order->{summa} = 200; # так делать - не ООП! Это только для примера my $discounter = DiscountFactory->new(type => "Visa"); print $order->get_summa(discounter => $discounter), "\n"; $discounter = DiscountFactory->new(type => "yandex"); print $order->get_summa(discounter => $discounter), "\n";

На выходе

Реализация

Класс Заказ

Package Order; sub new { return bless {}, shift } sub get_summa { my $self = shift; my $opt = {@_}; my $summa = $opt->{discounter}->do(summa => $self->{ summa }); return $summa; } 1;

Фабрика DiscountFactory (ее кода здесь нет, там все как и в обычной фабрике) возвращает объекты класса либо DiscountVisa , либо DiscountYM:

Package DiscountVisa; sub new { return bless {}, shift } sub do { my $self = shift; my $opt = {@_}; # Здесь я позволила себе использовать # «магическое число» --- это только для наглядности # примера. Так делать плохо. return $opt->{summa} * (1 - 0.02); } package DiscountYM; sub new { return bless {}, shift } sub do { my $self = shift; my $opt = {@_}; return $opt->{summa} * (1 + 0.05); } 1;

В классе Order у нас есть метод get_summa , который возвращает конечную стоимость заказа, но он должен учитывать и скидку на заказ. А скидка на заказ определяется способом оплаты заказа.

my $discounter = DiscountFactory->new(type => "Visa") - создали наш объект-дискаунтер, который знает, как считать скидку при оплате картой Visa.

$order->get_summa(discounter => $discounter) - вызываем метод для получения итоговой стоимости заказа, передавая туда нашу «стратегию» расчета скидки.

my $summa = $opt->{discounter}->do(summa => $self->{ summa }); - в методе get_summa мы вызываем операцию применения скидки к нашей базовой стоимости заказа.

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

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

←

Последнее обновление: 31.10.2015

Что представляют собой паттерны проектирования? Паттерн представляет определенный способ построения программного кода для решения часто встречающихся проблем проектирования. В данном случае предполагается, что есть некоторый набор общих формализованных проблем, которые довольно часто встречаются, и паттерны предоставляют ряд принципов для решения этих проблем.

Хотя идея паттернов как способ описания решения распространенных проблем в области проектирования появилась довольно давно, но их популярность стала расти во многом благодаря известной работе четырех авторов Эриха Гаммы, Ричарда Хелма, Ральфа Джонсона, Джона Влиссидеса, которая называлась "Design Patterns: Elements of Reusable Object-Oriented Software" (на русском языке известна как "Приемы объектно-ориентированного проектирования. Паттерны проектирования") и которая вышла в свет в 1994 году. А сам коллектив авторов нередко называют "Банда четырёх" или Gang of Four или сокращенно GoF. Данная книга по сути являлась первой масштабной попыткой описать распространенные способы проектирования программ. И со временем применение паттернов стало считаться хорошей практикой программирования.

Что же дает нам применение паттернов? При написании программ мы можем формализовать проблему в виде классов и объектов и связей между ними. И применить один из существующих паттернов для ее решения. В итоге нам не надо ничего придумывать. У нас уже есть готовый шаблон, и нам только надо его применить в конкретной программе.

Причем паттерны, как правило, не зависят от языка программирования. Их принципы применения будут аналогичны и в C#, и в Jave, и в других языках. Хотя в рамках данного руководства мы будем говорить о паттернах в контексте языка C#.

Также мышление паттернами упрощает групповую разработку программ. Зная применяемый паттерн проектирования и его основные принципы другому программисту будет проще понять его реализацию и использовать ее.

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

Существует множество различных паттернов, которые решают разные проблемы и выполняют различные задачи. Но по своему действию их можно объединить в ряд групп. Рассмотрим некоторые группы паттернов. В основу классификации основных паттернов положена цель или задачи, которые определенный паттерн выполняет.

Порождающие паттерны

Порождающие паттерны - это паттерны, которые абстрагируют процесс инстанцирования или, иными словами, процесс порождения классов и объектов. Среди них выделяются следующие:

Строитель (Builder)

Прототип (Prototype)

Одиночка (Singleton)

Другая группа паттернов - структурные паттерны - рассматривает, как классы и объекты образуют более крупные структуры - более сложные по характеру классы и объекты. К таким шаблонам относятся:

Адаптер (Adapter)

Мост (Bridge)

Компоновщик (Composite)

Декоратор (Decorator)

Фасад (Facade)

Приспособленец (Flyweight)

Заместитель (Proxy)

Третья группа паттернов называются поведенческими - они определяют алгоритмы и взаимодействие между классами и объектами, то есть их поведение. Среди подобных шаблонов можно выделить следующие:

Команда (Command)

Интерпретатор (Interpreter)

Итератор (Iterator)

Посредник (Mediator)

Хранитель (Memento)

Наблюдатель (Observer)

Состояние (State)

Стратегия (Strategy)

Шаблонный метод (Template method)

Посетитель (Visitor)

Существуют и другие классификации паттернов в зависимости от того, относится паттерн к классам или объектам.

Паттерны классов описывают отношения между классами посредством наследования. Отношения между классами определяются на стадии компиляции. К таким паттернам относятся:

Фабричный метод (Factory Method)

Интерпретатор (Interpreter)

Шаблонный метод (Template Method)

Адаптер (Adapter)

Другая часть паттернов - паттерны объектов описывают отношения между объектами. Эти отношения возникают на этапе выполнения, поэтому обладают большей гибкостью. К паттернам объектов относят следующие:

Абстрактная фабрика (Abstract Factory)

Строитель (Builder)

Прототип (Prototype)

Одиночка (Singleton)

Мост (Bridge)

Компоновщик (Composite)

Декоратор (Decorator)

Фасад (Facade)

Приспособленец (Flyweight)

Заместитель (Proxy)

Цепочка обязанностей (Chain of responsibility)

Команда (Command)

Итератор (Iterator)

Посредник (Mediator)

Хранитель (Memento)

Наблюдатель (Observer)

Состояние (State)

Стратегия (Strategy)

Посетитель (Visitor)

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

И в данном руководстве мы рассмотрим наиболее основные и распространенные паттерны и принципы их использования применительно к языку C#.

Как выбрать нужный паттерн?

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

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

И в конечном счете надо придерживаться принципа KISS (Keep It Simple, Stupid) - сохранять код программы по возможности простым и ясным. Ведь смысл паттернов не в усложнении кода программы, а наоборот в его упрощении.

В паттерне "Модель - представление - контроллер " модель представляет данные приложения и связанную с ними бизнес-логику. Модель может быть представлена одним объектом или сложным графом связанных объектов. В приложении для плат­формы Java ЕЕ данные инкапсулируются в объектах предметной области, часто раз­вертываемых в EJB-модуле. Данные передаются в БД и из нее в объектах передачи данных (ОТО), и к ним обращаются с помощью объектов доступа к данным (ОАО).

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

Язык Jаvа обеспечивает готовую для использования реализацию паттерна "Наблю­датель" . Разработчики легко могут реализовать этот паттерн с помощью интерфей­са Observer и расширения класса Observable .

Первое, что нам необходимо сделать - это создать класс, расширяющий класс Observable. В следующем примере когда новостное агентство оповещает несколько типов подпис­чиков в момент публикации нового материала. Подписчик может добавить соб­ственное поведение после получения обновления.

Язык Jаvа с самого начала поддерживал потоки, которые вы легко можете исполь­зовать для выполнения асинхронного кода :

public class AsyncRunnable implements Runnable { public void run() { System.out.println("Running!"); } }

public class AsyncRunnable implements Runnable { public void run () { System . out . println ("Running!" ) ;

Для выполнения класса Runnable инициализируйте его в потоке и вызовите метод run , обратившись к методу start() только что созданного потока.

Опубликовано в | Метки , | |

Паттерн программирования "Асинхронность " - особый, хорошо интегрирован­ный случай множественных потоков. Вследствие самой сущности потоков много­ поточные модели нуждаются в системах уведомления и зависят от шаблонного кода для запуска потоков.

Асинхронные обращения используются даже в одногопоточных средах, таких как NodeJS. Почти все пользовательские интерфейсы поддерживают асинхронное выполнение для удержания UI в активном, реагирующем на действия пользовате­ля состоянии.

Тем не менее асинхронное программирование может быть полезным и в других местах, помимо пользовательских интерфейсов, обычно на серверной стороне. Hи J2SE , ни J2ЕЕ не предоставляли встроенной "легкой" реализации для асинхрон­ного программирования.

Опубликовано в | Метки , | |

Паттерн "Декоратор" Java динамически добавляет объекту поведение во время выпол­нения или тогда, когда невозможно или нецелесообразно создавать производные классы (возможно, потому, что при этом создаются множественные подклассы).

Показывает, как добавить поведение к объекту пиццы во вре­мя выполнения на основе сделанного посетителем выбора.

Функциональность интерфейса программирования приложений (API ) может быть расширена и усовершенствована посредством оборачивания в декоратор. Подобным образом часто декорируются потоки данных. java.iо.BufferedInputStream - хороший пример декоратора, оборачивающего низкоуровневое API и добавля­ющего функциональность буферу потока ввода.

Приложения Laravel, нам неплохо было бы понять архитектуру каркаса приложения . Некоторые могут спросить: Зачем это нужно? Смысл забивать себе голову разной теоретической чепухой?
Постараюсь ответить на этот вопрос примером из жизни:

Представьте себе, что вы хотите иметь эксклюзивный автомобиль. Естественно он будет строиться на базе некоей серийной модели, но для того, чтобы его построить вам потребуется помощь людей, которые умеют это делать. Вы решаете обратиться к мастерам или даже к фирмам, у которых есть все необходимое: знания, опыт, оборудование и инструмент, но их услуги не дешевы, Ваш бюджет просто не выдержит таких расходов. Тогда вы решаете, что будете строить автомобиль самостоятельно. Отличное решение - правда, вы берете в руки инструмент, плюете на изучение теории, внедряете свои задумки и в итоге…

Я думаю, не стоит описывать, что у вас получится в итоге, ясно только одно - ничего хорошего.

Ну и более приближенный к теме Laravel 4 ответ: Понимание архитектуры приложения , знание основ паттернов (шаблонов) проектирования , помогут вам понять, почему следует использовать именно этот каркас web-приложения, оценить его слабые и сильные стороны. Так же вы получите ответ, почему так сильно изменился Laravel 4 по сравнению с Laravel 3.

Для тех, кто все же решил изучить теорию, прежде чем приступить к практике, советую: запаситесь терпением.

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

Определения

• Архитектура приложения - это логическая структура, описывающая отдельные компоненты, их свойства и связи в виде единой системы.
• Паттерны - это описания схем детализации отдельных подсистем приложения и взаимосвязей между ними. При этом паттерны не являются частью программы, не влияют прямо на ее структуру и сохраняют полную независимость от языка программирования конкретной системы.
• MVC - программная парадигма архитектурных паттернов : модель - представление - контроллер.

Паттерны это не так сложно как кажется

Если Вы спокойно и уверенно ориентируетесь в паттернах и парадигмах, то смело можете пропускать эту часть статьи. Но если, читая определения, Вы чувствуете, что это просто набор слов, то не поленитесь прочитать представленный ниже материал. Я надеюсь, он поможет вам разобраться в этой не очень простой для многих программистов теме и начать использовать паттерны в своей работе.

На самом деле паттерны не так сложны для понимания, как кажется на первый взгляд. Давайте проиллюстрируем их примерами, все сразу станет намного понятнее.

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

1. Вася и Петя встретились.
2. Вася протянул Пете руку.
3. Петя сказал «Здравствуй Вася» .
4. Вася ответил «Здравствуй Петя» .
5. Вася спросил «Ты принес мне диск с курсовой?» .
6. Петя ответил «Да, принес» .
7. Вася полез в карман и достал деньги.
8. Вася отсчитал 100$.
9. Вася передал деньги Пете.
10. Петя принял деньги от Васи.
11. Петя пересчитал деньги.
12. Петя кивнул головой - подтверждая, что сумма соответствует цене за диск.
13. Петя положил деньги в карман.
14. Петя достал диск.
15. Петя передал диск Васе.
16. Вася принял диск от Пети.
17. Вася положил диск в карман.

Теперь разобьём эту программу на отдельные части:

1. Начало программы.
2. Встреча.
3. Обмен приветствиями.
4. Проверка наличия «данных» .
5. Передача данных «деньги» .
6. Списание данных «деньги» .
7. Проверка данных «деньги» .
8. Запись данных «деньги» .
9. Передача данных «диск» .
10. Списание данных «диск» .
11. Запись данных «диск» .
12. Конец программы.

У нас получился алгоритм действий для встречи и обмена диска на деньги между двумя индивидуумами.

Теперь разбиваем алгоритм на составляющие так:

1. Общение.
2. Обмен данными.
3. Проверка условий.
4. Действия.

У нас как раз и получился набор паттернов (правда очень абстрактный). Зато этот архитектурный паттерн или программная парадигма описывает обмен данными практически любого вида и любой сложности. По сути это аналог всем известного MVC .

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

Давайте попробуем составить схему таких паттернов самостоятельно:

1. Общение
   1. Установление контакта
   2. Передача запросов между пользователем и системой
2. Обмен данными
   1. Передача данных запроса в направлении в систему
   2. Передача данных запроса в направлении из системы
   3. Передача команд на проверку условий
   4. Передача команд на передачу данных
3. Проверка условий
   1. Проверка условий передачи данных
   2. Подтверждение проверки условий
4. Действия
   1. Извлечение данных из хранилища «А»
   2. Передача данных в хранилище «А»

В итоге у нас получилась своя схема паттернов.

Теперь, если мы опишем, как конкретно взаимодействуют наши паттерны между собой - то получим рабочие паттерны. Причем паттерны будут достаточно универсальными, чтобы на их основе писать приложения не только для общения людей, но и для общения инопланетян.

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

Паттерны бывают разными

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

• Классификация по масштабу
• Классификация по стилю
• Классификация по применению

Классификация по масштабу

Самая часто используемая классификация - это классификация по масштабу. Чаще всего она применяется для паттернов проектирования и делится на три слоя по детализации:

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

Классификация по стилю

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

Классификация по применению

Программистам редко приходится сталкиваться с данным классом паттернов, но все же стоит о нем упомянуть, чтобы иметь хотя бы общее представление. Это самый высокоуровневый класс паттернов. В него входят целые классы паттернов. Например:

• Паттерны тестирования
• Паттерны документирования
• Паттерны организации производственных процессов
• Паттерны организации рабочих мест

И многие другие. Но я надеюсь их уже не нужно расписывать, вы вполне теперь способны продолжить этот список и без моих подсказок.

Заключение

Какие преимущества дают нам паттерны? Отвечу на этот вопрос, цитируя John Vlissides ( Влиссидес):

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

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

Для тех, кого заинтересовали паттерны, советую найти и почитать книги:

• Э. Гамма, Р. Хелм, Р. Джонсон, Д. Влиссидес: Приемы ООП. проектирования .
• Джон Влиссидес: шаблонов проектирования . Дополнительные штрихи.