Статьи

Введение в ObjectTeams / Java, ролевый подход к модульности с AOP

Недавно я наткнулся на интересный проект Eclipse под названием ObjectTeams / Java (OT / J), который обещает улучшенное повторное использование и обслуживание, а также поддержку развиваемых архитектур за счет создания хорошо инкапсулированных пакетов поведенческих модулей, которые можно применять к существующим классам (через AOP ), когда они находятся в соответствующем контексте взаимодействия (а не просто всегда, как в случае с АОП). Примером приложения является добавление ограничения NonNull к JDT через плагин OT / Equinox , без необходимости изменять базовые классы JDT. Я решил записать свои открытия, так как в проекте отсутствует четкое и краткое введение (хотя в остальном у него очень хорошая документация). Этот блог сильно заимствует из [1].

Отказ от ответственности: Я ни в коем случае не претендую на полное понимание OT / J :-)

Так что же такое OT / J?

Ключевыми понятиями являются роли, контексты, в которых используется объект («команды»), модули и разделение интересов.

Ролитрадиционно используются при моделировании предметной области: роль Клиента может играть физическое лицо, компания,… OT / J добавляет явную поддержку ролей, чтобы поведение, относящееся только к конкретной роли, было реализовано в классе, представляющем роль, который применяется к базовому классу сущностей. Ниже на рисунке 1 видно, что профессор организации может играть роль руководителя для некоторых докторов наук, а также лектора на некоторых курсах, в этом конкретном примере профессор Смит читает лекции по ООП и разработке программного обеспечения. Поведение, связанное с лекциями, такое как «аккуратно писать на доске» (у докторов есть достаточно времени, чтобы читать его обычные рукописные тексты) и передача слайдов и раздаточных материалов, реализовано в классе ролей «Лектор». Благодаря такому разделению интересов, с ростом числа ролей, которые может играть конкретная сущность,базовый класс не становится все более раздутым. Роли могут изменять или повторно использовать поведение своих базовых классов и могут раскрывать или скрывать любые свойства и методы базовых классов.

Рис. 1 (Источник: точная модель для контекстных ролей: язык программирования ObjectTeams / Java .)

Контексты взаимодействия , называемые командамив терминологии OT / J — это пространство, в котором живут роли, поскольку роль имеет смысл только в определенном контексте, таком как преподавание курса или участие в программе PhD — вы также можете подумать о случаях использования высокого уровня. Команды служат в основном двум целям в OT / J: во-первых, они группируют связанные роли вместе (придумайте пакет). Во-вторых, они позволяют активировать или деактивировать все роли одновременно — например, когда профессор и группа студентов входят в комнату курса, тогда поведение, определенное ролями лектора и участника, будет активировано и изменит / улучшит их поведение для продолжительность урока. Эта возможность включать / выключать модификации поведения в зависимости от контекста, в котором используется класс, довольно приятна. Кроме того, команда может иметь свой собственный набор методов и свойств, потому что она представлена ​​классом.

Модульность и возможность повторного использования достигаются путем реализации независимых поведений в виде ролей, сгруппированных в команды и применяемых к базовым классам во время выполнения. OT / J предлагает среднюю дорогу для модульности между структурами белого ящика и компонентами черного ящика и позволяет развить и адаптировать систему, избегая при этом большого количества изменений в базовых классах. В одном из примеров, которые я видел, используется абстрактная команда с подписчиком, которая собирает кредит для некоторых бонусных элементов. Затем команда специализируется на конкретной команде FlightBonus, которая применяет это поведение к существующим классам сущностей «Пассажир» и «Полет», где «кредит», который получают, — это бонусные мили. Та же абстрактная команда может быть применена к покупателю магазина, делающему покупки с помощью карточки покупателя и получающей некоторый бонус за каждую покупку.

Для чего это?

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

Сами авторы испытали следующие преимущества:

На техническом уровне применение OT / J для реализации своих собственных инструментов Herrmann & Mosconi (2007) продемонстрировало значительно улучшенную ремонтопригодность компонентов, которые повторно используют и адаптируют существующие компоненты.

Как это реализовано?

OT / J расширяет синтаксис Java, чтобы изначально поддерживать концепции команды, роли и расширения / модификации существующего поведения базовых классов. Вы компилируете его с помощью специального OT / J-компилятора, а затем он применяет ткачество во время загрузки, чтобы фактически разрешить применение ролей к их базовым классам. Команды и их роли активируются либо неявно, когда вы вызываете метод в классе Team, активация длится в течение всего вызова, либо явно, так что роль может применяться, даже если клиент объекта не знает об этом (для Например, система бронирования авиабилетов, возможно, не должна знать или заботиться о том, что есть некоторая поддержка для сбора бонусных миль).

Пример синтаксиса, показывающий команду и замену метода в базовом классе Main (краткий совет на языке AOP):

public class Main { public String sayMore() {...} }
...
public team class MyTeam {

protected class MyRole playedBy Main {
callin static void sayMore() {
System.out.println("callin begins ...");
base.sayMore();
System.out.println("callin ends ...");
}
sayMore <- replace sayHello;
}
}

Резюме

  • Роль — это класс, который явно ссылается на класс, который он изменяет / улучшает. Во время выполнения вносимые изменения вносятся в базовый класс, когда он находится в соответствующем контексте.

    • Методы базового класса могут быть модифицированы в стиле «все вокруг» («callin-binding») с использованием «aRoleMethod <- replace aBaseClassMethod»
    • Методы базового класса могут быть представлены ролью («callout-binding»): «aDelegatingRoleMethod -> aBaseClassMethod»
    • Также свойства базового класса могут быть представлены через методы получения / установки: «getARoleGetter -> get aBaseClassField»
  • Team — это класс, который может содержать роли — как вложенные классы, так и в структуре папок / файлов в стиле пакета — и свои собственные методы и свойства. Роли имеют ссылку на свою команду. Когда команда активирована, OT / J пытается автоматически применить свои роли к приемлемым взаимодействующим объектам на основе их типов (программист может настроить это с помощью «предикатов защиты»).

В чем разница между AOP и OT / J?

АОП имеет дело только с внедрением кода, и обычно один и тот же код (совет) применяется к нескольким методам в нескольких классах. OT / J — это нечто большее, чем его явная поддержка ролей и команд и их контекстно-зависимая активация. Также метод в роли обычно модифицирует только один метод в одном базовом классе, поэтому отображение не 1: N, как в AOP, а 1: 1.

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

Смотрите [2] для более глубокого обсуждения.

Вывод

Разделение проблем не всегда легко, потому что нам часто приходится применять одинаковое или очень похожее поведение в нескольких местах, а ООП не всегда поддается извлечению и повторному использованию поведения. AOP может помочь в этом, внедряя поведение, определенное в одном месте, во все места, где оно необходимо, но когда его мощность чрезмерно используется, очень трудно понять структуру времени выполнения программы, просто взглянув на ее исходные коды. OT / J делает здесь очень хороший компромисс, позволяя ролям изменять существующие классы, но делая приложение явным и равным 1: 1 (возможна дальнейшая возможность повторного использования путем определения общей функциональности в абстрактной команде и привязки ее к другому набору сущностей через конкретную подпрограмму). команды, как в примере FlightBonus). Используя язык бизнес-анализа, такой как роли,OT / J облегчает понимание и применение этой техники к реальным проектам.

OT / J, безусловно, выглядит очень интересно и может принести большую пользу сложному проекту, если его правильно применить. Конечно, он менее заметен, чем АОП низкого уровня, например, AspectJ.

OT / J ss в настоящее время находятся в стадии инкубации из-за недавнего перехода на Eclipse, но проект существует примерно с 2003 года, поэтому он должен быть довольно зрелым. Есть также инструментальные средства, поддерживающие его, например, набор плагинов Eclipse.

По словам разработчиков, проект выполняет то, что обещает:

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

Ресурсы

 

От http://theholyjava.wordpress.com/2011/03/27/introduction-to-objectteamsjava-a-role-based-approach-to-modularity-with-aop/