WikiDer > Свободный интерфейс - Википедия

Fluent interface - Wikipedia
Эта статья о шаблоне проектирования API. Информацию о пользовательском интерфейсе, представленном в Microsoft Office 2007, см. Microsoft Office 2007 § Пользовательский интерфейс. Язык визуального дизайна Microsoft 2017 см. Система свободного дизайна.

В программная инженерия, а свободный интерфейс является объектно-ориентированный API чей дизайн во многом опирается на цепочка методов. Его цель - повысить удобочитаемость кода путем создания предметно-ориентированный язык (DSL). Термин был введен в обращение в 2005 г. Эрик Эванс и Мартин Фаулер.[1]

Выполнение

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

  • Определяется через возвращаемое значение вызываемого метода
  • Самореференциальный, где новый контекст эквивалентен последнему контексту
  • Прекращено возвращением пустота контекст

Обратите внимание, что «свободный интерфейс» означает больше, чем просто каскадирование методов через цепочку; это влечет за собой разработку интерфейса, который читается как DSL, с использованием других методов, таких как «вложенные функции и область видимости объекта».[1]

История

Термин «свободный интерфейс» был введен в обращение в конце 2005 года, хотя этот общий стиль интерфейса восходит к изобретению каскадирование методов в Болтовня в 1970-х годах и многочисленные примеры в 1980-х годах. Типичным примером является iostream библиотека в C ++, который использует << или же >> операторы для передачи сообщений, отправки нескольких данных одному и тому же объекту и разрешения «манипуляторов» для вызовов других методов. Другие ранние примеры включают Гранатовая система (с 1988 в Лиспе) и Система амулетов (с 1994 года в C ++), который использовал этот стиль для создания объектов и присвоения свойств.

Примеры

C #

C # широко использует свободное программирование в LINQ для построения запросов с использованием «стандартных операторов запроса». Реализация основана на методы расширения.

вар переводы = новый Словарь<нить, нить>                   {                       {"Кот", "чат"},                       {"собака", "чиен"},                       {"рыбы", "пуассон"},                       {"птица", "уаз"}                   };// Находим переводы английских слов, содержащих букву "а",// сортируется по длине и отображается в верхнем регистреIEnumerable<нить> запрос = переводы	.Где   (т => т.Ключ.Содержит("а"))	.Сортировать по (т => т.Ценить.Длина)	.Выбирать  (т => т.Ценить.ToUpper());// Тот же запрос, построенный постепенно:вар фильтрованный   = переводы.Где (т => т.Ключ.Содержит("а"));вар отсортированный     = фильтрованный.Сортировать по   (т => т.Ценить.Длина);вар finalQuery = отсортированный.Выбирать      (т => т.Ценить.ToUpper());

Интерфейс Fluent также можно использовать для объединения набора методов, которые работают / совместно используют один и тот же объект. Вместо создания класса клиентов мы можем создать контекст данных, который можно украсить плавным интерфейсом следующим образом.

// Определяет контекст данныхучебный класс Контекст{    общественный нить Имя { получать; набор; }    общественный нить Фамилия { получать; набор; }    общественный нить Секс { получать; набор; }    общественный нить Адрес { получать; набор; }}учебный класс Покупатель{    частный Контекст _context = новый Контекст(); // Инициализирует контекст    // устанавливаем значение для свойств    общественный Покупатель Имя(нить имя)    {        _context.Имя = имя;        возвращаться это;    }    общественный Покупатель Фамилия(нить фамилия)    {        _context.Фамилия = фамилия;        возвращаться это;    }    общественный Покупатель Секс(нить секс)    {        _context.Секс = секс;        возвращаться это;    }    общественный Покупатель Адрес(нить адрес)    {        _context.Адрес = адрес;        возвращаться это;    }    // Выводит данные на консоль    общественный пустота Распечатать()    {        Консоль.WriteLine("Имя: {0}  nФамилия: {1}  nПол: {2}  nАдрес: {3}", _context.Имя, _context.Фамилия, _context.Секс, _context.Адрес);    }}учебный класс Программа{    статический пустота Главный(нить[] аргументы)    {        // Создание объекта        Покупатель c1 = новый Покупатель();        // Использование цепочки методов для назначения и печати данных одной строкой        c1.Имя("винод").Фамилия("шривастав").Секс("мужчина").Адрес("Бангалор").Распечатать();    }}

C ++

Обычное использование свободного интерфейса в C ++ это стандарт iostream, какие цепи перегруженные операторы.

Ниже приведен пример предоставления оболочки свободного интерфейса поверх более традиционного интерфейса в C ++:

 // Базовое определение учебный класс GlutApp { частный:     int w_, час_, Икс_, y_, argc_, Режим отображения_;     char **argv_;     char *заглавие_; общественный:     GlutApp(int argc, char** argv) {         argc_ = argc;         argv_ = argv;     }     пустота setDisplayMode(int Режим) {         Режим отображения_ = Режим;     }     int getDisplayMode() {         возвращаться Режим отображения_;     }     пустота setWindowSize(int ш, int час) {         w_ = ш;         час_ = час;     }     пустота setWindowPosition(int Икс, int у) {         Икс_ = Икс;         y_ = у;     }     пустота setTitle(const char *заглавие) {         заглавие_ = заглавие;     }     пустота Создайте(){;} }; // Базовое использование int главный(int argc, char **argv) {     GlutApp приложение(argc, argv);     приложение.setDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_ALPHA|GLUT_DEPTH); // Устанавливаем параметры фреймбуфера     приложение.setWindowSize(500, 500); // Устанавливаем параметры окна     приложение.setWindowPosition(200, 200);     приложение.setTitle(«Мое приложение OpenGL / GLUT»);     приложение.Создайте(); } // Свободная оболочка учебный класс FluentGlutApp : частный GlutApp { общественный:     FluentGlutApp(int argc, char **argv) : GlutApp(argc, argv) {} // Наследуем родительский конструктор     FluentGlutApp &withDoubleBuffer() {         setDisplayMode(getDisplayMode() | GLUT_DOUBLE);         возвращаться *это;     }     FluentGlutApp &сRGBA() {         setDisplayMode(getDisplayMode() | GLUT_RGBA);         возвращаться *это;     }     FluentGlutApp &withAlpha() {         setDisplayMode(getDisplayMode() | GLUT_ALPHA);         возвращаться *это;     }     FluentGlutApp &withDepth() {         setDisplayMode(getDisplayMode() | GLUT_DEPTH);         возвращаться *это;     }     FluentGlutApp &через(int ш, int час) {         setWindowSize(ш, час);         возвращаться *это;     }     FluentGlutApp &в(int Икс, int у) {         setWindowPosition(Икс, у);         возвращаться *это;     }     FluentGlutApp &названный(const char *заглавие) {         setTitle(заглавие);         возвращаться *это;     }     // Нет смысла создавать цепочку после create (), поэтому не возвращайте * this     пустота Создайте() {         GlutApp::Создайте();     } }; // Беглое использование int главный(int argc, char **argv) {     FluentGlutApp(argc, argv)         .withDoubleBuffer().сRGBA().withAlpha().withDepth()         .в(200, 200).через(500, 500)         .названный(«Мое приложение OpenGL / GLUT»)         .Создайте(); }

Ява

В jOOQ Библиотека моделирует SQL как свободный API на Java. Пример ожидаемого беглого тестирования в среде тестирования jMock:[1]

насмехаться.ожидает(однажды()).метод("м").с( или же(строкаСодержит("Привет"),                                          строкаСодержит("привет")) );
Автор автор = АВТОР.в качестве("автор");Создайте.выбрать из(автор)      .куда(существуют(Выбери один()                   .из(КНИГА)                   .куда(КНИГА.ПОЛОЖЕНИЕ ДЕЛ.экв(BOOK_STATUS.РАСПРОДАННЫЙ))                   .и(КНИГА.AUTHOR_ID.экв(автор.Я БЫ))));

В грипп процессор аннотаций позволяет создавать свободный API с использованием аннотаций Java.

В JaQue библиотека позволяет Java 8 Lambdas быть представленными как объекты в форме деревья выражения во время выполнения, что делает возможным создание безопасных по типу интерфейсов, т.е. вместо:

Покупатель объект = ...объект.свойство("имя").экв("Джон")

Можно написать:

метод<Покупатель>(покупатель -> покупатель.getName() == "Джон")

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

Коллекция mockCollection = EasyMock.createMock(Коллекция.учебный класс);EasyMock    .ожидать(mockCollection.удалять(ноль))    .и бросить(новый Исключение нулевого указателя())    .Хотя бы один раз();

В Java Swing API интерфейс LayoutManager определяет, как объекты-контейнеры могут управлять размещением компонентов. Один из самых мощных LayoutManager реализациями является класс GridBagLayout, который требует использования GridBagConstraints класс, чтобы указать, как происходит управление макетом. Типичный пример использования этого класса выглядит примерно так.

GridBagLayout gl = новый GridBagLayout();JPanel п = новый JPanel();п.setLayout( gl );JLabel л = новый JLabel("Имя:");JTextField нм = новый JTextField(10);GridBagConstraints gc = новый GridBagConstraints();gc.gridx = 0;gc.решетчатый = 0;gc.наполнять = GridBagConstraints.НИКТО;п.Добавить( л, gc );gc.gridx = 1;gc.наполнять = GridBagConstraints.ГОРИЗОНТАЛЬНО;gc.весx = 1;п.Добавить( нм, gc );

Это создает большой объем кода и затрудняет понимание того, что именно здесь происходит. В Упаковщик class предоставляет свободный механизм, поэтому вместо этого вы должны написать:[2]

JPanel п = новый JPanel();Упаковщик pk = новый Упаковщик( п );JLabel л = новый JLabel("Имя:");JTextField нм = новый JTextField(10);pk.пакет( л ).gridx(0).решетчатый(0);pk.пакет( нм ).gridx(1).решетчатый(0).fillx();

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

JavaScript

Есть много примеров библиотек JavaScript, в которых используются некоторые варианты этого: jQuery наверное, самый известный. Обычно для реализации «запросов к базе данных» используются свободные конструкторы, например в https://github.com/Medium/dynamite :

// получаем элемент из таблицыклиент.getItem('user-table')    .setHashKey('ID пользователя', 'userA')    .setRangeKey('столбец', '@')    .выполнять()    .тогда(функция(данные) {        // data.result: результирующий объект    })

Простой способ сделать это в JavaScript - использовать наследование прототипов и это.

// пример из https://schier.co/blog/2013/11/14/method-chaining-in-javascript.htmlучебный класс Котенок {  конструктор() {    это.имя = 'Гарфилд';    это.цвет = 'апельсин';  }  Имя набора(имя) {    это.имя = имя;    возвращаться это;  }  setColor(цвет) {    это.цвет = цвет;    возвращаться это;  }  спасти() {    консоль.бревно(      `экономия ${это.имя}, то ${это.цвет} котенок    );    возвращаться это;  }}// используй этоновый Котенок()  .Имя набора("Салем")  .setColor('чернить')  .спасти();

Scala

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

учебный класс Цвет { def rgb(): Tuple3[Десятичный] }объект Чернить расширяет Цвет { отменять def rgb(): Tuple3[Десятичный] = ("0", "0", "0"); }черта GUIWindow {  // Методы рендеринга, которые возвращают это для плавного рисования  def set_pen_color(цвет: Цвет): этот тип  def move_to(позиция: Позиция): этот тип  def line_to(позиция: Позиция, end_pos: Позиция): этот тип  def оказывать(): это.тип = это // Ничего не рисуйте, просто верните это, чтобы дочерние реализации могли свободно использовать  def верхний левый(): Позиция  def Нижний левый(): Позиция  def в правом верхнем углу(): Позиция  def внизу справа(): Позиция}черта WindowBorder расширяет GUIWindow {  def оказывать(): GUIWindow = {    супер.оказывать()      .move_to(верхний левый())      .set_pen_color(Чернить)      .line_to(в правом верхнем углу())      .line_to(внизу справа())      .line_to(Нижний левый())      .line_to(верхний левый())   }}учебный класс SwingWindow расширяет GUIWindow { ... }вал appWin = новый SwingWindow() с WindowBorderappWin.оказывать()

Раку

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

учебный класс Наемный рабочий {    подмножество Зарплата         из Настоящий куда * > 0;    подмножество NonEmptyString из Ул.  куда * ~~ /  S /; # хотя бы один непробельный символ    имеет NonEmptyString $ .name    является rw;    имеет NonEmptyString $. фамилия является rw;    имеет Зарплата         $. зарплата  является rw;    метод суть {        возвращаться qq: до [КОНЕЦ];        Имя: $ .name        Фамилия: $ .surname        Заработная плата: $. Зарплата        КОНЕЦ    }}мой $ сотрудник = Наемный рабочий.новый();данный $ сотрудник {    .имя    = 'Салли';    .фамилия = 'Поездка';    .зарплата  = 200;}сказать $ сотрудник;# Выход:# Имя: Салли# Фамилия: Поездка# Заработная плата: 200

PHP

В PHP, можно вернуть текущий объект, используя $ это специальная переменная, представляющая экземпляр. Следовательно вернуть $ this; заставит метод вернуть экземпляр. В приведенном ниже примере определяется класс Наемный рабочий и три способа установить его имя, фамилию и зарплату. Каждый возвращает экземпляр Наемный рабочий класс, позволяющий связывать методы.

учебный класс Наемный рабочий{    частный нить $ name;    частный нить $ surName;     частный нить $ зарплата;    общественный функция Имя набора(нить $ name)    {        $ это->имя = $ name;        возвращаться $ это;    }    общественный функция setSurname(нить $ фамилия)    {        $ это->фамилия = $ фамилия;        возвращаться $ это;    }    общественный функция setSalary(нить $ зарплата)    {        $ это->зарплата = $ зарплата;        возвращаться $ это;    }    общественный функция __нанизывать()    {        $ employeeInfo = 'Имя: ' . $ это->имя . PHP_EOL;        $ employeeInfo .= 'Фамилия: ' . $ это->фамилия . PHP_EOL;        $ employeeInfo .= 'Зарплата: ' . $ это->зарплата . PHP_EOL;        возвращаться $ employeeInfo;    }}# Создайте новый экземпляр класса Employee, Tom Smith, с окладом 100:$ сотрудник = (новый Наемный рабочий())                ->Имя набора('Том')                ->setSurname('Смит')                ->setSalary('100');# Отобразить значение экземпляра Employee:эхо $ сотрудник;# Отображать:# Имя: Том# Фамилия: Смит# Заработная плата: 100

Python

В Python, возвращаясь себя в методе экземпляра - это один из способов реализации плавного шаблона.

Однако это не одобряется создателем языка, Гвидо ван Россум, и поэтому считается непифоническим (не идиоматическим).

учебный класс Стих:    def __в этом__(себя, заглавие: ул) -> Никто:        себя.заглавие = заглавие    def отступ(себя, пробелы: int):        "" "Отступите стихотворение с указанным количеством пробелов." ""        себя.заглавие = " " * пробелы + себя.заглавие        возвращаться себя    def суффикс(себя, автор: нить):        "" "Суффикс к стихотворению с именем автора." ""        себя.заглавие = ж"{себя.заглавие} - {автор}"        возвращаться себя
>>> Стих("Дорога не пройдена").отступ(4).суффикс("Роберт Фрост").заглавие'Дорога не пройдена - Роберт Фрост'

Быстрый

В Быстрый 3.0+ возвращается себя в функциях - это один из способов реализации плавного шаблона.

учебный класс Человек {    вар имя: Нить = ""    вар фамилия: Нить = ""    вар Любимая цитата: Нить = ""    @discardableResult    func набор(имя: Нить) -> Себя {        себя.имя = имя        возвращаться себя    }    @discardableResult    func набор(фамилия: Нить) -> Себя {        себя.фамилия = фамилия        возвращаться себя    }    @discardableResult    func набор(Любимая цитата: Нить) -> Себя {        себя.Любимая цитата = Любимая цитата        возвращаться себя    }}
позволять человек = Человек()    .набор(имя: "Джон")    .набор(фамилия: "Лань")    .набор(Любимая цитата: "Мне нравятся черепахи")

Неизменность

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

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

Пример JavaScript

Используя семантику копирования при записи, приведенный выше пример JavaScript выглядит следующим образом:

учебный класс Котенок {  конструктор() {    это.имя = 'Гарфилд';    это.цвет = 'апельсин';  }  Имя набора(имя) {    const копировать = новый Котенок();    копировать.цвет = это.цвет;    копировать.имя = имя;    возвращаться копировать;  }  setColor(цвет) {    const копировать = новый Котенок();    копировать.имя = это.имя;    копировать.цвет = цвет;    возвращаться копировать;  }  // ...}// используй этоconst котенок1 = новый Котенок()  .Имя набора("Салем");const котенок2 = котенок1  .setColor('чернить');консоль.бревно(котенок1, котенок2);// -> Котенок ({name: 'Салем', окрас: 'оранжевый'}), Котенок ({name: 'Салем', окрас: 'черный'})

Проблемы

Ошибки не могут быть зафиксированы во время компиляции

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

Отладка и отчеты об ошибках

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

Ява.нио.ByteBuffer.выделить(10).перемотка().предел(100);

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

Ява.нио.ByteBuffer    .выделить(10)    .перемотка()    .предел(100);

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

логирование

Еще одна проблема связана с добавлением операторов журнала.

ByteBuffer буфер = ByteBuffer.выделить(10).перемотка().предел(100);

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

ByteBuffer буфер = ByteBuffer.выделить(10).перемотка();бревно.отлаживать("Первый байт после перемотки" + буфер.получать(0));буфер.предел(100);

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

статический учебный класс ByteBufferExtensions{    общественный статический ByteBuffer Бревно(это ByteBuffer буфер, Бревно бревно, Действие<ByteBuffer> getMessage)    {        нить сообщение = getMessage(буфер);        бревно.отлаживать(сообщение);        возвращаться буфер;    } }// Использование:ByteBuffer    .Выделить(10)    .Перемотка назад()    .Бревно( бревно, б => "Первый байт после перемотки" + б.Получать(0) )    .Предел(100);

Подклассы

Подклассы в строго типизированный языкам (C ++, Java, C # и т. д.) часто приходится переопределять все методы из своего суперкласса, которые участвуют в свободном интерфейсе, чтобы изменить их возвращаемый тип. Например:

учебный класс А {    общественный А сделай это() { ... }}учебный класс B расширяет А{    общественный B сделай это() { супер.сделай это(); возвращаться это; } // Необходимо изменить возвращаемый тип на B.    общественный B сделай это() { ... }}...А а = новый B().сделай это().сделай это(); // Это будет работать даже без переопределения A.doThis ().B б = новый B().сделай это().сделай это(); // Это не сработает, если A.doThis () не будет переопределен.

Языки, способные выражать F-связанный полиморфизм можно использовать его, чтобы избежать этой трудности. Например:

Абстрактные учебный класс АннотацияA<Т расширяет АннотацияA<Т>> {	@SuppressWarnings("не отмечен")	общественный Т сделай это() { ...; возвращаться (Т)это; }}	учебный класс А расширяет АннотацияA<А> {}	учебный класс B расширяет АннотацияA<B> {	общественный B сделай это() { ...; возвращаться это; }}...B б = новый B().сделай это().сделай это(); // Работает!А а = новый А().сделай это();          // Тоже работает.

Обратите внимание, что для создания экземпляров родительского класса нам пришлось разделить его на два класса: АннотацияA и А, последний без содержимого (он будет содержать конструкторы, только если они необходимы). Подход можно легко расширить, если мы хотим иметь подклассы (и т. Д.):

Абстрактные учебный класс АннотацияB<Т расширяет АннотацияB<Т>> расширяет АннотацияA<Т> {	@SuppressWarnings("не отмечен")	общественный Т сделай это() { ...; возвращаться (Т)это; }}учебный класс B расширяет АннотацияB<B> {}Абстрактные учебный класс АннотацияC<Т расширяет АннотацияC<Т>> расширяет АннотацияB<Т> {	@SuppressWarnings("не отмечен")	общественный Т фу() { ...; возвращаться (Т)это; }}учебный класс C расширяет АннотацияC<C> {}...C c = новый C().сделай это().сделай это().фу(); // Работает!B б = новый B().сделай это().сделай это();       // Еще работает.

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

учебный класс А {    def сделай это(): это.тип = { ... } // возвращает это, и всегда это.}учебный класс B расширяет А{    // Переопределение не требуется!    def сделай это(): это.тип = { ... }}...вал а: А = новый B().сделай это().сделай это(); // Цепочка работает в обоих направлениях.вал б: B = новый B().сделай это().сделай это(); // И обе цепочки методов приводят к B!

Смотрите также

Рекомендации

  1. ^ а б c Мартин Фаулер, "FluentInterface", 20 декабря 2005 г.
  2. ^ "Интерфейс Pack200.Packer". Oracle. Получено 13 ноября 2019.

внешняя ссылка