Обработка событий java: Java. Обработка событий

Содержание

Работа с событиями в Spring

Видеогайд

6 ноября 2021

Тэги: Kotlin, rest, Spring, Spring Boot, YouTube.

Содержание

Публикуем событие
Обрабатываем событие
Выводы

Spring «из коробки» предоставляет простой механизм работы с событиями, которые позволяют уменьшить связность компонентов системы. Событие, которое возникает в одной точке приложения, может быть перехвачено и обработано в любой другой части приложения благодаря таким сущностям как publisher и eventListener.

Для примера рассмотрим rest-приложение на Kotlin, в котором есть некий метод с бизнес-логикой.

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

Данный материал также доступен в формате видео на Youtube.

Создадим собственный тип события (data-класс), унаследовав его от стандартного класса ApplicationEvent.

data class BusinessEvent(
val sourceObject: Any,
val payload: String,
): ApplicationEvent(sourceObject)

У этого класса есть два поля:

sourceObject для ссылки на объект, в котором возникло событие и который мы передаём в базовый класс события.
payload — полезная мета-информация. В данном случае просто кидаем строку текста.

Теперь нам осталось подтянуть стандартный компонент

ApplicationEventPublisher в нужную нам точку приложения и опубликовать через него наше событие.

Бизнесовый метод может выглядеть так:

@RestController
class BusinessController(
    val publisher: ApplicationEventPublisher,
) {
    @PostMapping
    fun create() {
        // бизнес-логика

        val event = BusinessEvent(
            sourceObject = this,
            payload = «Some information»
        )
        publisher.publishEvent(event)
    }
}

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

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

Теперь создадим сервис аудита, который будет «слушать» событие. Его интерфейс может выглядеть так:

interface AuditService {
fun onBusinessEvent(event: BusinessEvent)
}

Тогда реализация примет следующий вид:

@Service
class AuditServiceImpl : AuditService {

private val logger = LoggerFactory. getLogger(AuditServiceImpl::class.java)

    @EventListener(BusinessEvent::class)
    override fun onBusinessEvent(event: BusinessEvent) {
        logger.info(«Business event received: $event»)
    }
}

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

В нашем примере мы перехватываем событие типа BusinessEvent

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

Spring позволяет легко реализовать простейшую событийную модель в приложении. Прежде всего это снижает связность отдельных компонентов системы между собой. В дальнейшем такая архитектура позволит легко перейти на более «серьёзные» решения вроде полноценных очередей RabbitMQ или Kafka.

Облако тэгов

Kotlin, Java, Java 16, Java 11, Java 10, Java 9, Java 8, Spring, Spring Boot, Spring Data, SQL, PostgreSQL, Oracle, Linux, Hibernate, Collections, Stream API, многопоточность, файлы, Nginx, Apache, maven, gradle, JUnit, YouTube, новости, руководство, ООП, алгоритмы, головоломки, rest, GraphQL, Excel, XML, json, yaml.

Последние статьи

Список статей
Кеширование в Spring Boot
Springdoc для документации REST API
Работа с коллекциями в Kotlin и Java
Советы по работе с BigDecimal в Java
Алгоритм определения палиндрома
Удаление записи через DELETE-запрос в Spring Boot
Обновление записи через PUT-запрос в Spring Boot

Добавление записи через POST-запрос в Spring Boot
Работа с БД в Spring Boot на примере postgresql
Spring Boot Restful Service
Решето Эратосфена для поиска простых чисел
Алгоритм поиска простых чисел
Построчное чтение больших файлов на Java
Как сохранить текстовый файл на Java
Алгоритм чисел Фибоначчи на Java и Kotlin
Работа с системой контроля версий git из консоли
Бинарный поиск на отсортированном массиве
Как парсить HTML на Java с помощью Jsoup
Настройка Ubuntu под хостинг JVM приложения

НОУ ИНТУИТ | Лекция | Пакет java.

awt

< Практикум 2 || Лекция 11: 123456

Аннотация: Эта лекция начинает рассмотрение базовых библиотек Java, которые являются неотъемлемой частью языка и входят в его спецификацию, а именно описывается пакет java.awt, предоставляющий технологию AWT для создания графического (оконного) интерфейса пользователя – GUI. Ни одна современная программа, предназначенная для пользователя, не обходится без удобного, понятного, в идеале – красивого пользовательского интерфейса. С самой первой версии в Java существует специальная технология для создания GUI. Она называется AWT, Abstract Window Toolkit. Именно о ней пойдет речь в этой лекции. Пакет java.awt претерпел, пожалуй, больше всего изменений с развитием версий Java. Мы рассмотрим дерево компонентов, доступных программисту, специальную модель сообщений, позволяющую гибко обрабатывать пользовательские действия, и другие особенности AWT – работа с цветами, шрифтами, отрисовка графических примитивов, менеджеры компоновки и т. д. Хотя технология AWT включает в себя гораздо больше, чем можно изложить в рамках одной лекции, здесь собраны все необходимые сведения для создания полноценного оконного интерфейса.

Ключевые слова: Java, GUI, программа, производительность, AWT, Abstract Window Toolkit, слово, abstract, foreground, background, deprecated, monospace, пользовательское событие, radio button, splash screen, дерево, ООП, компонент, объект, event, garbage collector, параметр компонента, HTML, класс, инициализирующие действия, java script, координаты, приложение, пользователь, контейнер, интерфейс, фрейм, площадь, значение, controls, layout managers, место, шрифт, цикла, тег, апплет

Введение

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

Библиотеку назвали AWT – Abstract Window Toolkit. Слово abstract в названии указывает, что все стандартные компоненты не являются самостоятельными, а работают в связке с соответствующими элементами операционной системы.

Дерево компонентов

Component

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

Рассмотрим основные свойства этого класса.

Положение

Положение компонента описывается двумя целыми числами (тип int ) x и y. В Java (как и во многих языках программирования) ось x проходит традиционно – горизонтально, направлена вправо, а ось у – вертикально, но направлена вниз, а не вверх, как принято в математике.

Для описания положения компонента предназначен специальный класс – Point (точка). В этом классе определено два public int поля x и y, а также множество конструкторов и вспомогательных методов для работы с ними. Класс Point применяется во многих типах AWT, где надо задать точку на плоскости.

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

Установить положение компонента можно с помощью метода setLocation(), который может принимать в качестве аргументов пару целых чисел, либо Point. Узнать текущее положение можно с помощью метода getLocation(), возвращающего Point, либо с помощью методов getX() и getY(), которые появились с версии Java 1.2.

Размер

Как было сказано, компонент AWT имеет прямоугольную форму, а потому его размер описывается также двумя целочисленными параметрами – width (ширина) и height (высота). Для описания размера существует специальный класс Dimension (размер), в котором определено два public int поля width и height, а также вспомогательные методы.

Установить размер компонента можно с помощью метода setSize, который может принимать в качестве аргументов пару целых чисел, либо Dimension. Узнать текущие размеры можно с помощью метода getSize(), возвращающего Dimension, либо с помощью методов getWidth() и getHeight(), которые появились с версии Java 1.2.

Совместно положение и размер компонента задают его границы. Область, занимаемую компонентом, можно описать либо четырьмя числами ( x, y, width, height ), либо экземплярами классов Point и Dimension, либо специальным классом Rectangle (прямоугольник). Как легко догадаться, в этом классе определено четыре public int поля, с которыми можно работать и в виде пары объектов Point и Dimension.

Задать границу объекта можно с помощью метода setBounds, который может принимать четыре числа, либо Rectangle. Узнать текущее значение можно с помощью метода getBounds(), возвращающего Rectangle.

Видимость

Существующий компонент может быть как виден пользователю, так и быть скрытым. Это свойство описывается булевским параметром visible. Методы для управления – setVisible, принимающий булевский параметр, и isVisible, возвращающий текущее значение.

Разумеется, невидимый компонент не может взаимодействовать с пользователем.

Доступность

Даже если компонент отображается на экране и виден пользователю, он может не взаимодействовать с ним. В результате события от клавиатуры или мыши не будут получаться и обрабатываться компонентом. Такой компонент называется disabled. Если же компонент активен, его называют enabled. Как правило, компонент некоторым образом меняет свой внешний вид, когда становится недоступным (например, становится серым, менее заметным), но, вообще говоря, это необязательно (хотя очень удобно для пользователя).

Для изменения этого свойства применяется метод setEnabled, принимающий булевский параметр ( true соответствует enabled, false – disabled ), а для получения текущего значения – isEnabled.

Цвета

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

ru/2010/edi»>Компонент обладает двумя свойствами, описывающими цвета, – foreground и background цвета. Первое свойство задает, каким цветом выводить надписи, рисовать линии и т.д. Второе – задает цвет фона, которым закрашивается вся область, занимаемая компонентом, перед тем, как прорисовывается внешний вид.

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

Цвет задается 3 целочисленными характеристиками, соответствующими модели RGB, – красный, зеленый, синий. Каждая из них может иметь значение от 0 до 255 (тем не менее, их тип определен как int ). В результате (0, 0, 0) соответствует черному, а (255, 255, 255) – белому.

Класс Color является неизменяемым, то есть, создав экземпляр, соответствующий какому-либо цвету, изменить параметры RGB уже невозможно. Это позволяет объявить в классе Color ряд констант, описывающих базовые цвета: белый, черный, красный, желтый и так далее. Например, вместо того, чтобы задавать синий цвет числовыми параметрами (0, 0, 255), можно воспользоваться константами Color.blue или Color.BLUE (второй вариант появился в более поздних версиях).

Для работы со свойством компонента foreground применяют методы setForeground и getForeground, а для background – setBackground и getBackground.

Шрифт

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

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

Имя шрифта задает внешний стиль отображения символов. Имена претерпели ряд изменений с развитием Java. В версии 1.0 требовалось, чтобы JVM поддерживала следующие шрифты: TimesRoman, Helvetica, Courier. Могут поддерживаться и другие семейства, это зависит от деталей реализации конкретной виртуальной машины. Чтобы узнать полный список во время исполнения программы, можно воспользоваться методом утилитного класса Toolkit. Экземпляры этого класса нельзя создать вручную, поэтому полностью такой запрос будет выглядеть следующим образом:

Toolkit.getDefaultToolkit().getFontList()

В результате будет возвращен массив строк-имен семейств поддерживаемых шрифтов.

В Java 1.1 три обязательных имени были объявлены deprecated. Вместо них был введен новый список, который содержал более универсальные названия, не зависящие от конкретной операционной системы: Serif, SansSerif, Monospaced.

В Java 2 библиотека AWT была существенно пересмотрена и дополнена. Чтобы устранить неоднозначности с разной поддержкой шрифтов на разных платформах, было произведено разделение на логические и физические шрифты.

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

Первая группа состоит из 5 обязательных семейств (добавились Dialog и DialogInput ). JVM устанавливает соответствие между ними и наиболее подходящими из доступных физических шрифтов.

Метод getFontList класса Toolkit был объявлен deprecated. Теперь получить список всех доступных физических шрифтов можно следующим образом:

GraphicsEnvironment.
   getLocalGraphicsEnvironment().
   getAvailableFontFamilyNames()

Класс Font является неизменяемым. После создания можно узнать заданное логическое имя (метод getName ) и соответствующее ему физическое имя семейства (метод getFamily ).

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

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

Наконец, последний параметр – стиль. Этот параметр определяет, будет ли шрифт жирным, наклонным и т.д. Если никакие из этих свойств не требуются, указывается Font.PLAIN (параметр имеет тип int и в классе Font определен набор констант для удобства работы с ним). Значение Font.BOLD задает жирный шрифт, а Font.ITALIC – наклонный. Для сочетания этих свойств (жирный наклонный шрифт) необходимо произвести логическое сложение: Font.BOLD|Font.ITALIC.

intuit.ru/2010/edi»>Для работы с этим свойством класса Component предназначены методы setFont и getFont.

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

Существует еще одно важное свойство другого характера. Очевидно, что практически всегда пользовательский интерфейс состоит из более чем одного компонента. В больших приложениях их обычно гораздо больше. Для удобства организации работы с ними компоненты объединяются в контейнеры. В AWT существует класс, который так и называется – Container. Его рассмотрение – наша следующая тема. Важно отметить, что компонент может находиться лишь в одном контейнере – при попытке добавить его в другой он удаляется из первого. Рассматриваемое свойство как раз и отвечает за связь компонента с контейнером. Свойство называется parent. Благодаря ему компонент всегда «знает», в каком контейнере он находится.

Дальше >>

< Практикум 2 || Лекция 11: 123456