Контейнер Java Beans

Размещено на http://www.allbest.ru/

Оглавление

Введение

1 Обзор аналогов и доступных технологий

1.1 Принципы компонентно- ориентированного программирования

1.2 Применение компонентно-ориентированного программирования

1.3 Инструментальная поддержка компонентной модели JavaBeans

1.4 Анализ и выбор технологий

1.4.1 Выбор библиотеки графического интерфейса

1.4.2 Генерация классов, реализующих интерфейсы слушателей

2 Описание применяемых технологий

2.1 Компонентная модель JavaBeans

2.1.1 Основные понятия

2.1.2 Событийная модель

2.1.3 Интроспекция бинов

2.2 Предлагаемое решение

2.2.1 Организация графического интерфейса приложения

2.2.2 Описание библиотеки графического интерфейса

2.2.3 Загрузка компонентов в приложение

2.2.4 Использование Java Dynamic Proxy Class API

3 Особенности реализации

3.1 Графический интерфейс приложения

3.1.1 BeanListPanel

3.1.2 BeanManipulationPanel

3.1.3 GUIBeanWrapper

3.1.4 PropertySheetPanel

3.2 Связывание компонентов

3.2.1 BeanInvocationHandler

3.2.2 BeanBindingManager

3.2.3 Шаблон Одиночка в Java

Заключение

Список использованных источников



Введение

В ходе развития и эволюции методологии разработки программного обеспечения было предложено множество парадигм программирования, которые определяли стиль написания программ, определяли из каких элементов они должны состоять, а также какие подходы следует применять при написании кода. Одним из важнейших этапов этого развития стало появление компонентно - ориентированного подхода, основанного на идеях объектно-ориентированного программирования и расширяющего их. «Компонентно - ориентированное программирование (КОП) - это парадигма программирования, которая делает возможным конструирование программ из заранее созданных программных компонентов, являющихся повторно - используемыми, самостоятельными блоками компьютерного кода [6]. Оно является своего рода набором ограничений и правил, налагаемых на механизмы объектно - ориентированного программирования (ООП) для повышения надежности программных систем. Возникновение компонентно - ориентированного программирования как набора ограничений для ООП в некотором роде сходно с появлением структурного программирования, которое ограничивало использование неупорядоченных и бесконтрольных переходов в потоке управления программы с помощью оператора GOTO. В отличии от объектно - ориентированного программирования, которое оперировало понятием объекта - некоторой сущности, объединяющей в себе поля, то есть данные, и методы, который данный объект способен выполнить, КОП оперирует понятием компонента, то есть независимым модулем, который предназначается для повторного развертывания и использования. Компоненты могут быть реализованы в виде множества разных языковых конструкций (например, классов в терминах объектно - ориентированных языков). Компонентно - ориентированный подход предлагает быстро создавать гибкие системы, используя набор написанных ранее компонентов, комбинируя эти компоненты вместе, как строительные блоки. На данный момент компонентно-ориентированное программирование считается одной из самых широко-используемых парадигм программирования. Компонентно-ориентированный подход к разработке программного обеспечения был реализован в рамках многих языков программирования и разных платформ, в частности, в рамках объектно-ориентированных языков (будучи развитием принципов ООП, идеи КОП органично реализовывались в таких языках), таких, как, например, Java. В настоящее время Java является одним из самых популярных и широко используемых языков в мире. Для Java платформы было предложено множество компонентных моделей, однако самой популярной остается модель JavaBeans, предложенная компанией Sun Microsystems, разработчиком Java, в 1997 году вместе с первой версией языка. Данная модель будет подробно рассмотрена во второй главе. Однако для работы с компонентной моделью требуется инструмент, который бы её поддерживал и позволял бы манипулировать компонентами, и такой инструмент был представлен вместе с моделью Java Beans - Bean Development Kit. Он позволяет задавать свойства компонентов Java Beans с помощью графического интерфейса пользователя, создавать композиции компонентов, привязывая вызов метода компонента по срабатыванию события какого-либо компонента, а также сериализовать и десериализовать компоненты. Однако за более, чем пятнадцатилетнюю историю BDK не претерпевал никаких изменений и не обновлялся, хотя современные версии Java Development Kit предлагают много новых возможностей по сравнению с первой версией, таким образом, существующий инструмент является устаревшим.

«Java Development Kit (JDK) - бесплатно распространяемый компанией Oracle Corporation (ранее Sun Microsystems) комплект разработчика приложений на языке Java, включающий в себя компилятор Java (javac), стандартные библиотеки классов Java, примеры, документацию, различные утилиты и исполнительную систему Java (JRE)» [10]. Каждая новая версия JDK предоставляла новые возможности и технологии разработчикам, а также исправления ошибок и оптимизации. Одними из самых значимых нововведений в JDK за всю историю были:

· Введение в версии 1.2 библиотеки графического интерфейса Swing и коллекций.

· Введение Java Dynamic Proxy Class API в версии 1.3, позволяющее динамически создавать реализации интерфейсов без необходимости генерации исходного или байт кода.

· Добавление в версии 1.5 перечислимых типов, средств обобщенного программирования и автоматического преобразования между простыми типами и соответствующими типами - обертками, например, int - Integer.

· Введение Java Compiler API в версии 1.6, позволяющее использовать компилятор java, установленный в системе.

· Введение в версии 1.7 платформы JavaFX [15].

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

Целью данной работы является создание удобного инструмента для поддержки компонентно-ориентированного программирования в рамках Java платформы и модели JavaBeans, используя технологии, доступные в современном JDK.

В рамках данной цели были поставлены следующие задачи:

1. Проведение исследования существующих аналогов разрабатываемого инструмента и выявление их недостатков.

2. Исследование компонентной модели JavaBeans

3. Выявление, анализ и выбор технологий, предлагаемых современным JDK, которые могут быть использованы при реализации требуемого функционала.

4. Реализация инструмента, позволяющего манипулировать компонентами JavaBeans и создавать композиции из них, используя выбранные технологии.

В главе 1 будет подробно рассмотрен Bean Development Kit, а также другие аналоги и технологии, которые могут быть применены для разработки требуемого инструмента. В главе 2 будут подробно рассмотрены технологии, выбранные для реализации необходимой функциональности, и, наконец, в третьей главе будут рассмотрены подробности реализации программы.

компонентный программирование графический интерфейс



1. Обзор аналогов и доступных технологий

1.1 Принципы компонентно-ориентированного программирования

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

1. Он может быть использован другими программными элементами, то есть своими «клиентами».

2. Он обладает официальным описанием использования, которого достаточно для автора клиента, чтобы использовать этот компонент.

3. Он не привязан к какому - либо фиксированному набору клиентов [13].

В данном определении в общем говорится о том, что клиент должен быть использован другими программными элементами, то есть быть элементом композиции. Второе определение - «Компонент - это единица композиции с контрактно определенными интерфейсами и только явными контекстными зависимостями» [4]. Данное определение явно указывает на то, что у компонента должен быть определен интерфейс, с помощью которого он будет взаимодействовать с другими компонентами. Из этого и следует основная идея компонетно - ориентированного программирования, состоящая в том, чтобы создавать программные системы, комбинируя различные созданные ранее компоненты.



1.2 Применение компонентно-ориентированного программирования

Данный подход активно применяется, например, при разработке графического интерфейса пользователя. Практически во всех популярных средах разработки присутствует возможность проектировать интерфейсы, перетаскивая компоненты в рабочую область и изменяя их свойства с помощью графического интерфейса. Например, в случае разработки на Java, основные среды разработки, такие как Intellij Idea, NetBeans и Eclipse позволяют создавать пользовательские интерфейсы, используя компоненты библиотеки для создания графического интерфейса Swing.

Рисунок 1 Пример интерфейса манипуляции компонентом Swing в среде разработки IntelliJ IDEA

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

1.3 Инструментальная поддержка компонентной модели JavaBeans

Компания - разработчик Java и компонентной модели Java Beans - Sun Microsystems выпустила инструмент с требуемой функциональностью в 1997 году вместе со спецификацией компонентной модели - BeanBox. Данный инструмент позволял:

1. Загружать компоненты из JAR файлов.

2. Инстанциировать компоненты в рабочей области.

3. Изменять свойства инстанциированных компонентов.

4. Задавать вызов метода компонента по срабатыванию события какого-либо компонента.

5. Сериализовать и десериализовать компоненты.

6. Сохранять и загружать состояние рабочей области (всех инстанциированных компонентов вместе со связями)

BeanBox распространялся в виде исходного кода и был доступен на сайте Sun Microsystems. Однако после того, как компания Sun была поглощена компанией Oracle в 2010 году, BeanBox перестал быть публично доступным и скачать его с сайта Oracle невозможно. Кроме этого, BeanBox был разработан с использованием JDK 1.1, то есть на данный момент является устаревшим, так как за больше, чем 15 лет, Java платформа получила большое количество новых возможностей.

Для реализации графического интерфейса пользователя в BeanBox использовался Abstract Window Toolkit - стандартная и единственная библиотека графического интерфейса в Java 1.1. AWT предоставляет абстракцию над родными элементами пользовательского интерфейса, то есть создание какого-либо элемента управления, например, кнопки, влечет вызов системной подпрограммы, которая создает соответствующий элемент управления. Таким образом все приложения, написанные с использованием AWT выглядят как родные приложения системы [1].

Рисунок 2 Интерфейс BeanBox

AWT является устаревшей библиотекой графического интерфейса, уступив место Swing и JavaFX. AWT является платформозависимой библиотекой, так как она использует родные элементы управление системы, но не все элементы интерфейса одной системы, могут быть представлены и функционировать тем же образом в другой. Это противоречит философии Java - «Write once, run everywhere» - «Написано однажды, исполняется везде». Кроме этого сам интерфейс приложения не претерпевал никаких изменений с момента создания и является устаревшим. Инструмент представлен в виде трех независимых окон, тогда как все современные среды разработки организованы в виде docking view, который позволяет управлять панелями и как независимыми окнами, и как частью общего окна приложения. Такой подход предлагает большую гибкость и большее удобство использования. Docking view будет подробнее рассмотрен позднее. Помимо этого, BeanBox не поддерживает drag'n'drop, то есть отсутствует возможность инстанциировать компонент в рабочей области приложения, перетащив его из списка компонентов. Окно свойств выделенного компонента не адаптивно, так при изменении размера окна, элементы либо остаются неподвижными и не меняют свой размер, в случае увеличения размеров окна, при этом появляется много пустого пространства, в случае же уменьшения размеров окна, элементы скрываются даже, если оставшегося места достаточно для их размещения.

Помимо устаревшего и неудобного интерфейса у BeanBox имеются проблемы со связыванием компонентов между собой. В случае, если компонент Java Bean может порождать события, он предоставляет возможность другим компонентам подписаться на события данного типа, для этого подписчик должен предоставить реализацию интерфейса слушателя, требуемого источником событий (обычно унаследованного от интерфейса EventListener). Компонентная модель JavaBeans и её событийная модель будут рассмотрены в подробностях позднее. В актуальной на данный момент версии JDK (1.8) присутствует несколько способов динамически создавать такие реализации интерфейсов: Dynamic Proxy Class API, генерация исходного кода с последующей его компиляцией с помощью Java Compiler API, сторонние библиотеки для генерации байт-кода, однако все эти возможности появились в JDK после выхода BeanBox, поэтому в данном инструменте они не используются. Вместо этого BeanBox генерирует исходный код класса, реализующего требуемый интерфейс, записывает сгенерированный код в файловую систему компьютера, на котором он запущен, и запускает программу javac (стандартный компилятор java, поставляемый вместе с JDK) в отдельном процессе, используя класс Runtime. Компилятор javaс вызывается по стандартному для Windows пути - «C:\Program Files\Java\jdk<версия jdk>\javac». После этого скомпилированные классы загружаются в приложение. Такой подход создает проблемы с кроссплатформенностью: так как на не Windows системах, путь к установленному JDK совершенно другой, кроме того, даже в самой Windows JDK может быть установлен по пути, отличному от стандартного, более того, у разных версий jdk пути также отличаются, то есть пользователю необходимо задать путь к java компилятору в его системе и перекомпилировать приложение, а также повторять данную операцию каждый раз при обновлении jdk. Помимо упомянутых проблем, такой подход усложняет программу и делает более вероятным возникновение ошибок (например, при записи исходно года в файловую систему компьютера или при создании нового процесса и вызове java компилятора).

1.4 Анализ и выбор технологий

1.4.1 Выбор библиотеки графического интерфейса

Для реализации требуемого инструмента необходимо выбрать технологии, которые будут использоваться, прежде всего библиотеку графического интерфейса. Тремя основными библиотеками графического интерфейса для Java на данный момент являются Abstract Window Toolkit (AWT), Swing и JavaFX. Библиотека AWT была рассмотрена в предыдущем разделе, поэтому акцент будет поставлен на Swing и JavaFX.

Swing - библиотека для создания графического интерфейса, пришедшая на смену AWT, начиная с версии Java 1.2. Компоненты Swing являются «легковесными», то есть отрисовываются средствами самих компонентов, в отличии от компонентов AWT, которые используют стандартные компоненты интерфейса системы. Так как компоненты Swing не используют системные элементы интерфейса, они отображаются и функционируют одинаково на всех поддерживаемых платформах. Однако Swing поддерживает динамически подключаемые «виды и поведения» («look and feel»), что позволяет адаптировать внешний вид приложения к внешнему виду родных приложений системы, на которой оно запускается [12]. За свою долгую историю вокруг Swing сложилось большое и развитое сообщество разработчиков, было разработано большое количество сторонних компонентов для любых целей и был накоплен большой багаж знаний, следовательно, в случае возникновения проблем, велика вероятность, что она уже была решена.

JavaFX - это платформа для создания «Rich Internet Application» («Насыщенные (или богатые) интернет приложения) под различные среды: операционные системы, браузеры и даже мобильные телефоны, разработанная компанией Oracle. JavaFX включена в состав Java Runtime Environment (JRE), начиная с версии 1.7 [11]. Как и Swing, JavaFX не использует родные элементы интерфейса системы, таким образом являясь кроссплатформенным решением. JavaFX позволяет создавать интерфейс декларативно: с помощью XML подобного языка - FXML. JavaFX позиционируется Oracle как замена Swing, однако в обозримом будущем Oracle планируют включать в состав JRE и Swing, и JavaFX. В отличии от Swing, JavaFX пока еще не собрала вокруг себя такого большого и развитого сообщества и такого большого количества сторонних компонентов. Например, не удалось найти такой важный для требуемого инструмента компонент JavaFX, как docking view. Реализация же такого компонента своими силами потребовала бы большого количества сил и времени и выходит за рамки данной работы.

В Swing отсутствует стандартная реализация Docking view, поэтому было решено использовать сторонний компонент. Доступно большое количество подобных компонентов, однако многие из них либо имеют скудную документацию, либо не поддерживаются в течение некоторого времени. Однако была найдена библиотека с подробной документацией и активным форумом, на котором можно задавать вопросы по работе, который активно поддерживается и развивается (последняя версия на момент написания работы была выпущена 3го мая 2015 года. Это библиотека Docking Frames [5].

1.4.2 Генерация классов, реализующих интерфейсы слушателей

Как было упомянуто ранее, для связывания вызова метода компонента и срабатывания события какого-либо компонента в BeanBox применялась генерация исходного кода с последующей компиляцией этого кода с помощью вызова стандартного java компилятора и загрузки скомпилированных классов в приложение. Такой подход не является кроссплатформенным и подвержен различным ошибкам. В современных версиях JDK существует несколько инструментов, позволяющих достичь требуемой цели: Dynamic Proxy Class API и Java Compiler API. Помимо этого, возможно использование сторонней библиотеки генерации java байт кода, например, Apache Byte Code Engineering Library [2].

Java Compiler API было представлено в Java с версии 1.6. Оно позволяет вызывать компилятор Java [9]. Помимо этого Java Compiler API позволяет собирать диагностическую информацию, тем самым контролируя процесс компиляции и отслеживая возможные ошибки. Ниже следует пример получения компилятора, доступного в системе и его вызова для компиляции файла “MyClass.java”.

По String sourceFileName = "src" + File.pathSeparator + "MyClass.java";

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

int res = compiler.run(null, null, null, sourceFileName);

дход к связыванию компонентов с использованием Java Compiler API идентичен подходу, примененному в BeanBox, так как также требует генерации исходного java кода и загрузки скомпилированных классов, однако позволяет избавиться от некроссплатформенного и подверженного ошибкам вызова java компилятора в отдельном, только что созданном процессе и необходимости перекомпиляции приложения при изменении пути к компилятору. Однако, данный подход, в отличие от двух других, которые будут описаны далее, требует наличие java компилятора в системе (при этом java компилятор входит в состав JDK, но не JRE).

Другой подход к связыванию компонентов - генерация java байт кода напрямую без создания исходного кода и использования компилятора. Самой распространенной библиотекой для таких целей является Apache Byte Code Engineering Library [2]. Она позволяет создавать java класс файлы (файлы, содержащие байт код) и манипулировать ими. И хотя класс, реализующий интерфейс слушателя, необходимый для связывания компонентов является довольно маленьким и не содержит сложной логики, использование такой библиотеки требует знания java байт кода и структуры class файлов. Например, вот так выглядит добавление метода к сгенерированному пустому классу:

MethodGen mg = new MethodGen(ACC_STATIC | ACC_PUBLIC, // access flags

Type.VOID, // return type

new Type[] { // argument types

new ArrayType(Type.STRING, 1) },

new String[] { "argv" }, // arg names

"main", "HelloWorld", // method, class

il, cp);

InstructionFactory factory = new InstructionFactory(cg);

Java Dynamic Proxy Class API появилось в Java, начиная с версии 1.3. Оно позволяет динамически создавать прокси классы, реализующие заданный во время исполнения список интерфейсов, таким образом, что при вызове у экземпляра такого класса какого-либо из методов одного из интерфейсов, этот вызов будет передан объекту - обработчику [7]. Java Dynamic Proxy Class API позволяет обойтись без использования дополнительных инструментов таких, как, например, java компилятор или генератор байт кода, и не генерировать классы вручную, вместо этого, создание прокси классов производится внутренними механизмами Java Virtual Machine (JVM). Данный подход выглядит наиболее оптимальным и удобным для реализации требуемого инструмента. Использование Java Dynamic Proxy API будет рассмотрено далее в работе.



2. Описание применяемых технологий

2.1 Компонентная модель JavaBeans

2.1.1 Основные понятия

Суть компонентно-ориентированного программирования состоит в написании повторно используемых компонентов, чтобы в последующем составлять из них программы, как из независимых строительных блоков. Целью данной работы было поддержать модель JavaBeans, как самую популярную компонентную модель для Java. Эта модель была создана в 1997 году компаний Sun Microsystems, чтобы позволить сторонним разработчикам создавать Java компоненты для будущего использования конечным пользователем. Согласно спецификации, Java Bean - это повторно используемый программный компонент, которым можно манипулировать с помощью графических инструментов [14]. Особую популярность Java Beans снискали как компоненты графического интерфейса пользователя, так, многие компоненты AWT и Swing являются Java Beans. В языке Java Java Bean - это класс, отвечающий некоторым требованиям, таким как:

1. Класс должен быть иметь публичный (с модификатором доступа public) конструктор по умолчанию (конструктор без параметров).

2. Класс должен поддерживать сериализацию (то есть реализовывать интерфейс java.io.Serializable)

3. Свойства класса должны быть доступны через методы доступа (аксессоры и мутаторы), именованные следующим образом: setXXX для мутатора и getXXX или isXXX в случае, если свойство имеет тип boolean или Boolean, для аксессоров, где XXX - имя соответствующего свойства с большой буквы.

Java Bean не должен наследоваться ни от какого класса, однако Java Bean'ам, у которых есть графическое представление, необходимо наследовать класс java.awt.Component, чтобы такие классы могли быть отображены в среде разработки [14]. Одной из важных частей компонентной модели Java Beans является событийная модель, которая позволяет связывать компоненты между собой в рамках событийно - ориентированного программирования («event - driven programming»).

2.1.2 Событийная модель

Событийная модель Java Beans основана на двух понятиях: источник событий и подписчик (или обработчик событий). Источники событий должны предоставить методы, которые бы позволяли подписчикам подписаться и получать в дальнейшем события соответствующего типа, а также отписаться от данного типа событий. Обычно такие методы именуются как addXXXListener и removeXXXListener соответственно, где XXX - тип события, которое представляет интерес для подписчика. При возникновении события, источник оповещает всех подписчиков, вызывая определенный метод интерфейса слушателя, реализация которого была передана в качестве аргумента методу addXXXListener. Подписчик, в случае, если он желает подписаться на события какого-либо типа, должен вызвать соответствующий метод addXXXListener объекта - источника событий, передавая в качестве аргумента реализацию требуемого интерфейса - слушателя. В случае, если источнику события, требуется передать информацию о произошедшем событии, он может определить любой список параметров в методе интерфейса - слушателя, например, такой метод может принимать аргумент типа, отнаследованного от класса EventObject, содержащего в себе информацию об источнике событий, а также дополнительную информацию о событии, включенную туда самим источником.

2.1.3 Интроспекция бинов

Так как, компоненты Java Bean предлагается использовать в визуальной среде разработки, они должны быть доступны для интроспекции, то есть динамического определения доступных свойств и событий. Существует два способа получения такой информации: механизм рефлексии Java и классы, содержащие требуемую информацию, поставляемые с компонентом его разработчиком. Рефлексия работает за счет внутренних механизмов JVM и принципов именований методов доступа, описанных ранее. Данный механизм позволяет определить, от какого класса наследуется компонент, какие интерфейсы он реализует, а также какие методы предоставляет. Механизм рефлексии предлагает следующие классы, содержащую информацию о компоненте Java Bean:

1. BeanDescriptor - класс, предоставляющий глобальную информацию о Java Bean, такую как, например, класс компонента и его имя.

2. PropertyDescriptor - класс, предоставляющий информацию о свойстве компонента в виде пары методов доступа.

3. MethodDescriptor - класс, предоставляющий информацию о методах, предоставляемых компонентом.

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

Помимо механизма рефлексии, информация о компоненте может быть доступна из информационного класса, в случае, если разработчик предоставил его вместе с компонентом. Такие классы должны иметь имя XXXBeanInfo, где XXX - имя класса компонента, и быть наследником класса SimpleBeanInfo или же реализовывать интерфейс BeanInfo. Объект такого класса предоставляет информацию о компоненте в виде классов, описанных выше.



2.2 Предлагаемое решение

2.2.1 Организация графического интерфейса приложения

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

2.2.2 Описание библиотеки графического интерфейса

В качестве библиотеки графического интерфейса было решено использовать Swing, включенный в Java Runtime, начиная с версии 1.2. Swing предоставляет более гибкие компоненты интерфейса по сравнению с Abstract Window Toolkit. Помимо этого, компоненты Swing не используют системные компоненты для отрисовки интерфейса, поэтому являются стопроцентно портируемыми между платформами, которые поддерживает Java. В Swing появился интерфейс Border, позволяющий создавать объекты, рисующие границу вокруг краев компонентов Swing, тем самым упрощая реализацию манипуляции компонентами JavaBean (например, перемещение и изменение размеров) по сравнению с оригинальным BDK, реализованным с помощью AWT, где приходилось вручную рисовать границы и отслеживать перемещение мыши внутри них и даже изменять курсор. Помимо этого, в Swing появилась стандартная реализация Drag-n-Drop функциональности, которая позволила сделать более удобным для пользователя процесс добавления компонентов в рабочую область. Так же в Swing появился стандартный компонент JTable, представляющий собой таблицу, которой можно задавать, каким образом будут отрисовываться клетки таблицы, расширяя стандартную функциональность. Это позволило создать более удобную и гибкую панель отображения и задания свойств выделенного компонента. В отличие от панели оригинального BDK, панель, реализованная средствами Swing, подстраивает свой размер под размеры окна, свойства могут быть отсортированы, размер столбцов изменен в соответствии с доступным пространством и пожеланиями пользователя. Для отображения и редактирования свойств были использованы как стандартные диалоги, предоставляемые Swing (например, JColorChooser для выбора цвета), так и реализованы новые посредством расширения функциональности стандартного JDialog (например, диалог выбора шрифтов). Для отображения и манипуляции компонентами JavaBeans была реализована «обертка», в виде стандартного компонента JComponent, которая служила контейнером для компонента, который нужно отобразить, также вокруг этой обертки рисуется граница, с помощью которой происходит изменение размеров компонента. Если компонент JavaBean, который нужно отобразить является наследником класса java.awt.Component, то есть у такого компонента есть графическое представление, этот компонент добавляется в «обертку» и отображается в рабочей области. В противном случае, для такого компонента создается графическое представление в виде белой панели, в центре которой находится текстовое представление компонента, полученное вызовом метода toString(). Описанная функциональность будет подробнее рассмотрена в следующей главе.

2.2.3 Загрузка компонентов в приложение

Введение в Java 1.2 класса URLClassLoader позволило упростить процесс загрузки компонентов JavaBeans в приложение. Согласно официальной документации Oracle, URLClassLoader служит в качестве основного загрузчика расширений и JAR файлов, перегружая метод findClass класса java.lang.ClassLoader таким образом, чтобы искать классы по заданным URL. В данной работе URLClassLoader используется для загрузки компонентов JavaBeans из JAR файлов, предоставленных пользователем, в отличии от BDK, в котором разработчикам пришлось реализовывать свой загрузчик классов для загрузки пользовательский компонентов JavaBean в приложение и регистрировать его в качестве обработчика протоколов из-за отсутствия в первой версии Java дерева загрузчика классов.

2.2.4 Использование Java Dynamic Proxy Class API

Одной из главных проблем оригинального BDK было генерация классов, реализующий интерфейсы - слушатели для подписки на события компонентов. Для этого использовался вызов java компилятора посредством создания нового процесса. Недостатки такого подхода были описаны в предыдущих главах. В данной работе использовалось Java Dynamic Proxy API, введенное в Java 1.3. Dynamic Proxy API позволяет создавать реализации динамически заданных интерфейсов во время выполнения программы без необходимости генерации кода. Такой подход позволил избавиться от проблем с кроссплатформенностью, необходимости указания пути к исполняемому файлу java компилятора и сделать приложение более надежным, устранив необходимость вызова компилятора в отдельном процессе. Для использования Java Dynamic Proxy Class API необходимо реализовать интерфейс InvocationHandler, содержащий единственный метод invoke. Данный метод принимает в качестве параметров сам прокси объект, а также метод, который был вызван и аргументы, переданные ему. Ниже приведен пример реализации интерфейса InvocationHandler и пример создания прокси объекта, реализующего интерфейс MyInterface.

public Object invoke(Object proxy, Method method, Object[] args) {

System.out.println(method.toString());

return null;

}

}

InvocationHandler handler = new MyInvocationHandler();

MyInterface proxy = (MyInterface) Proxy.newProxyInstance(

MyInterface.class.getClassLoader(),

new Class[]{MyInterface.class},

handler);

public class MyInvocationHandler implements InvocationHandler {

В данном примере, объект proxy реализует динамически заданный интерфейс MyInterface и при вызове какого-либо метода данного интерфейса напечатает в стандартный поток вывода строковое представление вызванного метода.



3. Особенности реализации

3.1 Графический интерфейс приложения

Как было упомянуто ранее, интерфейс приложения состоит трех панелей, организованных в docking view. Так как в Swing отсутствует стандартный компонент docking view, была использована сторонняя библиотека Docking frames [5]. Она проста в использовании. В качестве отсоединяемой панели выступает объект класса DefaultSingleCDockable, реализующего интерфейс SingleCDockable, содержащий три свойства: заголовок панели, иконку и компонент для отображения. Объекты типа DefaultSingleCDockable создаются однажды, добавляются к контроллеру и остаются в памяти пока явно не будут удалены из контроллера или приложение не завершится. Для создания docking view прежде всего требуется создать контроллер, который будет управлять панелями, позволяя отсоединять их и возвращать на прежнее место. За это отвечает класс CControl. При создании контроллера ему требуется передать главное окно приложения, которым в данном случае является объект класса MainFrame, наследующий класс JFrame. Содержимым главного окна выступает объект класса CContentArea - наследника JComponent, для получения ссылки на этот объект требуется вызвать метод getContentArea контроллера. Ниже представлен исходный код создания и инициализации docking view.

mainControl = new CControl(this);

this.setLayout(new GridLayout(1, 1));

this.add(mainControl.getContentArea());

SingleCDockable beanListDockable = this.getBeanListDockable();

Single CDockable main Pane lDockable = this. Get Bean Manipulation Dockable();

Single CDockable properties List Dockable = this. Get Properties List Dockable();

mainControl.addDockable(beanListDockable);

mainControl.addDockable(mainPanelDockable);

mainControl.addDockable(propertiesListDockable);

Переменная mainControl была объявлена заранее. В качестве компонента для отображения в каждом из трех DefaultSingleCDockable выступала соответствующая панель: панель отображения списка загруженных компонентов - объект класса BeanListPanel, главная панель, на которой происходит отображение инстанциированых компонентов и манипуляция ими - объект класса BeanManipulationPanel и панель, отображающая свойства выделенного компонента - объект класса PropertySheetPanel, каждый из трех упомянутых классов является наследником класса JPanel.

Рисунок 3 Внешний вид приложения после запуска

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



3.1.1 BeanListPanel

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

private SingleCDockable getBeanListDockable() {

DefaultSingleCDockable dockable = new DefaultSingleCDockable("beanPanel", "Beans", beanListPanel);

CButton loadJarButton = new CButton("Load Jar", new ImageIcon(this.getClass().getClassLoader().getResource("jar8.png")));

loadJarButton.addActionListener(e -> {

JFileChooser fileChooser = new JFileChooser();

fileChooser.setCurrentDirectory(new File(System.getProperty("user.dir")));

fileChooser.setFileFilter(new FileNameExtensionFilter("Jar files (*.jar)", "jar"));

if (fileChooser.showOpenDialog(MainFrame.this) == JFileChooser.APPROVE_OPTION) {

try {

MainFrame.this.loadJar(fileChooser.getSelectedFile());

} catch (IOException ex) {

LOG.warning(ex.getMessage());

}

}

});

dockable.addAction(loadJarButton);

return dockable;

}

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

public interface GUIBeanManipulator {

void addBean(Object bean) throws IntrospectionException;

void addBean(Object bean, Point location) throws IntrospectionException;

void serializeComponentBinary(GUIBeanWrapper wrapper);

void serializeComponentXML(GUIBeanWrapper wrapper);

void readSerializedComponentBinary();

void readSerializedComponentXML();

void serializeAllComponentsXML();

void readAllComponentsXML();

void removeBean(GUIBeanWrapper wrapper);

}

Класс DefaultSingleCDockable поддерживает добавление компонентов управления в заголовок панели. Так, например, панель отображения списка загруженных компонентов содержит в заголовке кнопку, по нажатию на которую пользователю предоставляется диалог выбора JAR файла, из которого нужно загрузить компоненты JavaBeans. Загрузка классов происходит с помощью URLClassLoader, загружаются только те классы, для которых в манифесте указано JavaBean: True, то есть такой класс является компонентом Java Bean.

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

Рисунок 4 Панель списка загруженных компонентов с использованием компонента "аккордеон"

3.1.2 BeanManipulationPanel

DefaultSingleCDockable объект, содержащий панель, отображающую инстанциированные компоненты, создается аналогично DefaultSingleCDockable объекту, содержащему панель, отображающую список загруженных компонентов. Класс BeanManipulationPanel реализует интерфейс GUIBeanManipulator, описанный в предыдущем разделе, и является наследником JLayeredPane, а не JPanel, так как требовалось, чтобы выделенный компонент перекрывал неактивные компоненты, соответственно, когда какой-либо компонент на данной панели получает фокус, он перемещается на самый верхний слой. Конструктор класса BeanManipulationPanel принимает ссылку на объект класса, реализующего интерфейс BeanInfoDisplay, содержащий методы для отображения свойств выделенного компонента на панели свойств и очистки панели, когда ни один из компонентов не находится в фокусе.

public interface BeanInfoDisplay {

void showProperties(PropertyDescriptor[] descriptors, Object bean);

void clearSheet();

}

3.1.3 GUIBeanWrapper

Для возможности перетаскивания компонента по панели и отрисовки границы вокруг компонента, с помощью которой, можно изменять его размеры, был создан класс GUIBeanWrapper, наследующий JComponent. Один из конструкторов GUIBeanWrapper принимает в качестве аргумента сам java бин, а также компонент для отображения (если java бин является наследником класса Component, таким компонентом является сам бин, в противном случае - отображается панель с белым фоном, содержащая в центре строковое представление бина, полученное вызовом метода toString). Остальные конструкторы имеют дополнительные параметры, такие как точка, в которой следует отобразить инстанциированный компонент и границу, которую следует отобразить вокруг него. Для корректной работы самого инстанциированного компонента, объект GUIBeanWrapper передает все события мыши (такие как движения мыши, клики и т.д.) компоненту.

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

3.1.4 PropertySheetPanel

Для отображения свойств выделенного компонента была создан класс PropertySheetPanel, наследующий класс JPanel. Панель содержит объект класса JTable с двумя колонками: имя свойства и значение свойства. Использование таблицы позволило добавить возможность сортировки свойств по алфавиту и изменения размера колонок. Помимо этого, таблица изменяет свой размер в зависимости от размера всей панели, сжимаясь или растягиваясь при необходимости. Класс JTable позволяет задавать собственные визуализаторы (англ. renderer) и редакторы (англ. editor) для различных типов свойств. Так, например, свойство типа Color отображается с помощью прямоугольника, заполненного соответствующим цветом, десятеричным значением каждой из трех компонент RGB и шестнадцатеричным представлением цвета, для задания же цвета применяется стандартный Swing диалог выбора цвета. Помимо этого, PropertySheetPanel позволяет добавить отображение описания свойства в отдельной панели (если описание присутствует, в противном случае отображается имя свойства).

Рисунок 6 Панель свойств с включенной сортировкой и отображением описания выделенного свойства. Выделено свойство foreground.

3.2 Связывание компонентов

3.2.1 BeanInvocationHandler

Как было сказано ранее, для создания реализаций интерфейса слушателя был использован Java Dynamic Proxy Class API, позволяющий динамически создавать реализации интерфейсов. Сначала было необходимо создать класс, реализующий интерфейс InvocationHandler, который перехватывает и обрабатывает вызов методов реализуемого интерфейса. Ниже приведен исходный код данного класса.

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

Object result = null;

if (method.equals(eventMethod)) {

result = targetMethod.invoke(target, null);

}

return result;

}

}

Конструктор класса BeanInvocationHandler принимает на вход 3 параметра: объект, метод которого нужно вызвать при наступлении события, метод, который нужно вызвать, и метод интерфейса слушателя, который вызовет объект - источник при наступлении события (это необходимо, так как интерфейс слушатель может иметь несколько методов).

3.2.2 BeanBindingManager

Dynamic Proxy Class API используется в классе - перечислении BeanBindingManager. Ниже приведен его исходный код.

public enum BeanBindingManager {

INSTANCE();

private EventBindingGroup eventGroup;

public void setEventGroup(EventBindingGroup eventGroup) {

this.eventGroup = eventGroup;

}

public void bind(TargetBindingGroup targetGroup) {

if (eventGroup == null) return;

Method listenerMethod = eventGroup.getAddListenerMethod();

Object proxy = Proxy.newProxyInstance(

getClass().getClassLoader(),

new Class[]{listenerMethod.getParameterTypes()[0]},

new BeanInvocationHandler(targetGroup.getTargetObject(), targetGroup.getTargetMethod(), eventGroup.getEventMethod()));

try {

listenerMethod.invoke(eventGroup.getEventSource(), proxy);

} catch (IllegalAccessException | InvocationTargetException e) {

e.printStackTrace();

}

eventGroup = null;

}

public boolean isChoosingTarget() {

return eventGroup != null;

}

public void cancelBinding() {

eventGroup = null;

}

}

Для более удобного связывания компонентов было создано два класса: EventBindingGroup, содержащий ссылку на объект - источник событий, ссылку на метод, с помощью которого можно подписаться на события, и ссылку на метод интерфейса слушателя, который будет вызван источником при наступлении события, и TargetBindingGroup, содержащий ссылку на объект, метод которого должен быть вызван при наступлении события, и ссылку на сам метод. Класс BeanBindingManager было решено реализовать, применив паттерн проектирования «Одиночка», так как требовалось, чтобы в приложении был только один глобальный объект BeanBindingManager. В таком случае отсутствует возможность совершить ошибку при связывании компонентов из-за использования неверной ссылки на объект BeanBindingManager.



3.2.3 Шаблон Одиночка в Java

«Шаблон одиночка гарантирует, что у класса есть только один экземпляр, и предоставляет к нему глобальную точку доступа.» [16]. Существует несколько способов реализации одиночки в java, однако, начиная с версии 1.5, в которой появились классы - перечисления, лучшим способом является использование класса - перечисления.

public enum Elvis {

INSTANCE;

public void leaveTheBuilding() {...}

Помимо простоты и краткости такой подход обеспечивает потокобезопасность и возможность сериализации объекта одиночки.



Заключение

Компонентно - ориентированное программирование остается одной из самых широко используемых парадигм программирования, поддерживаемых разными языками, например, компонентной моделью JavaBeans в языке Java.

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

Направления дальнейшей работы могут включать в себя:

· Добавление возможности привязывать к событию вызов методов с параметрами.

· Добавление новых визуализаторов и редакторов для разных типов свойств.



Список использованных источников

1. Abstract Window Toolkit (AWT) [В Интернете] // Oracle Java Documentation. - Oracle. - 12 05 2015 г.. - http://docs.oracle.com/javase/8/docs/technotes/guides/awt/index.html.

2. Apache Commons BCEL [В Интернете] // Apache Commons. - The Apache Software Foundation. - 12 05 2015 г.. - http://commons.apache.org/proper/commons-bcel/.

3. Apache Commons BCEL - Byte Code Engineering Library (BCEL) [В Интернете] // Apache Commons. - The Apache Software Foundation. - 12 05 2015 г.. - https://commons.apache.org/proper/commons-bcel/manual.html.

4. Component Software: Beyond Object-Oriented Programming. [Книга] / авт. Szyperski C. - [б.м.] : Addison-Wesley Professional, 2011.

5. Docking Frames [В Интернете] // Docking Frames. - Java Forge. - 12 05 2015 г.. - http://dock.javaforge.com/index.html.

6. Dynamic component composition [Журнал] / авт. Гринкруг Ефим Михайлович. - [б.м.] : International Journal of Software Engineering & Applications (IJSEA), 2014 г.. - 4 : Т. 5.

7. Dynamic Proxy Classes [В Интернете] // Oracle Java Documentation. - Oracle. - 12 05 2015 г.. - http://docs.oracle.com/javase/8/docs/technotes/guides/reflection/proxy.html.

8. Effective Java Second Edition [Книга] / авт. Bloch Joshua. - [б.м.] : Addison - Wesley, 2008.

9. Java Compiler (Java Platform SE 7) [В Интернете] // Java SE Documentation. - Oracle. - 12 05 2015 г.. - ttp://docs.oracle.com/javase/7/docs/api/javax/tools/JavaCompiler.html.

10. Java Development Kit [В Интернете] // Википедия. - Wikimedia. - 12 05 2015 г.. - https://ru.wikipedia.org/wiki/Java_Development_Kit.

11. JavaFX Developer Home [В Интернете] // Oracle. - Oracle. - 12 05 2015 г.. - http://www.oracle.com/technetwork/java/javase/overview/javafx-overview-2158620.html.

12. Swing APIs and Developer Guides [В Интернете] // Oracle Java Documentation. - Oracle. - 12 05 2015 г.. - http://docs.oracle.com/javase/8/docs/technotes/guides/swing/index.html.

13. The grand challenge of trusted components [Конференция] / авт. Bertrand M // ICSE 25 (International Conference on Software Engineering). - 2003.

14. The JavaBeans API Speci?cation. / авт. Hamilton G. - [б.м.] : Sun Microsystems, 1997 г.

15. История версий Java [В Интернете] // Википедия. - Wikimedia. - 12 05 2015 г.. - https://ru.wikipedia.org/wiki/История_Версий_Java.

16. Приемы объектно-ориентированного проектирования. Паттерны проектирования [Книга] / авт. Влиссидес Джон [и др.]. - [б.м.] : Питер, 2001.

Размещено на Allbest.ru

...