Beginner's Guide to Groovy for Java Devs

Groovy - это еще один язык программирования, который был создан как дополнение к языку Java. Он работает поверх JRE, как и многие другие языки программирования, например, Scala или Kotlin. Следовательно, перенимает все плюсы языка Java и добавляет свои, что делает его достаточно интересным языком для изучения. Более того, он довольно часто встречается на практике в реальных проектах и будет очень нужен для изучения других курсов на канале dmdev.

00:00 - Введение
00:33 - Что такое Groovy
01:39 - Версии Groovy
02:03 - Особенности Groovy
03:10 - Динамический язык программирования
04:53 - Compilation and Runtime (Java & Groovy)
06:19 - Где используется Groovy
07:16 - Резюме

Для того, чтобы приступить к изучению языка программирования Groovy, нам необходимо установить соответствующее программное обеспечение. Нам понадобится Java как минимум 8 версии, потому что как мы поняли из предыдущего видео: Groovy работает поверх JRE. Cреда разработки - IntelliJ IDEA, т.к. у нее прекрасная поддержка Groovy. И в зависимости от того, будете вы использовать build tools (Maven, Gradle) или нет, нам возможно понадобится вручную скачать и установить Groovy.

00:00 - Введение
00:20 - Установка Java 16
00:56 - Установка IntelliJ IDEA
01:38 - Установка Groovy 3.0.8
03:15 - Создание Gradle проекта
05:13 - Создание Maven проекта
06:30 - Создание проекта без build tools

Изучение любого языка программирования начинается с классического написания первой программы, которая напишет в консоль "Hello World". Также начнем знакомиться с первыми отличиями Groovy от языка Java и попробуем понять разницу между Groovy классами и Groovy скриптами, проделав все через консоль.

00:00 - Введение
00:25 - Groovy Class "Hello World"
03:14 - Groovy Class bytecode
04:20 - Groovy Script "Hello World"
05:14 - Groovy Script bytecode
07:22 - Утилиты groovyc и groovy
10:22 - Резюме

Мы уже встречались на предыдущих курсах про такие понятия как загрузчик классов (ClassLoader) и пути указания JVM, где искать классы (ClassPath). Нам это занятии более подробно остановимся на этом вопросе, чтобы понять как запускаются groovy скрипты через утилиты groovy. Ведь скомпилированные groovy классы через утилиту groovyc и так просты и понятны, потому что сразу после компиляции у них точно такой же flow как и обычных Java классов.

00:00 - Введение
00:36 - Объекты класса Class
02:45 - JDK, JRE, JVM
04:05 - Основные Java ClassLoaders
09:30 - GroovyClassLoader

В Groovy те же типы данных, что и в Java, за маленьким исключением - нет примитивных типов данных, а точнее, они все представлены в виде классов-оболочек. Так же появились новые представления литеральных форм для таки типов как BigInteger и BigDecimal, которые даже не нужно импортировать для использования. Обсудим несколько нюансов по новому ключевому слову def, которое можно использовать не только для создания локальных переменных, как в Java с ключевым словом var.

00:00 - Введение
01:03 - Основные типы данных
02:01 - В Groovy нет примитивных типов данных
03:09 - BigInteger и BigDecimal
04:04 - imports
05:38 - Ключевое слово def
06:53 - Аннотация @CompileStatic

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

00:00 - Введение
00:31 - Арифметические операторы
02:42 - Приведение типов
04:08 - Унарные операторы и операторы присваивания
05:08 - Операторы сравнения
07:50 - Логические и побитовые операторы
08:36 - Резюме

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

00:00 - Введение
00:27 - 6 вариантов создания строк
01:15 - Строки с одинарными и двойными кавычками
01:51 - Интерполяция строк
02:51 - Класс GString
03:45 - Строки с тройными кавычками
05:29 - Объявление типа char
05:55 - Expression language в GString
07:05 - Slashy & Dollar slashy strings
08:21 - Операции со строками
09:56 - Резюме

Регулярные выражения - очень нужный и часто используемый инструмент, который должен стоять на вооружении каждого программиста. В Groovy еще больше упростили их использование, если сравнивать с Java. Теперь синтаксис стал более лаконичным и кратким. На видео рассмотрим его более детально и зайдем внутрь bytecode, чтобы посмотреть, как Groovy Parsers работают под капотом, чтобы представить такой новый синтаксис. 

00:00 - Введение
00:38 - Regex in Java
05:14 - Pattern in Groovy
05:46 - Matcher in Groovy
07:00 - Regex groups in Groovy
09:58 - Резюме

Замыкания (Closure) - это один из самых мощных инструментов в программировании. Он существует и в Java в виде lambda выражений, в которых также можно использовать переменные вне области lambda выражений. Но в Groovy пошли еще дальше. На видео рассмотрим только первую часть концепции замыканий, чтобы иметь общее представление о них и изучить дальнейший базовый материал. Во второй части курса разберем замыкания на более продвинутом уровне, который позволит нам углубиться в такое понятие как DSL, ведь именно он стал отправной точкой в развитии таких инструментов как Gradle, Jenkins, etc. 

00:00 - Введение
00:42 - Java lambda
02:54 - Класс Closure
06:01 - Синтаксис Closure
07:51 - Closure method reference
08:13 - Default method params value
08:44 - Closure bytecode
10:57 - Класс Reference
12:57 - Groovy DSL

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

00:00 - Введение
00:17 - Java if-else
00:59 - Groovy if-else
03:13 - Метод asBoolean
05:10 - if-else bytecode
06:17 - null-safe operator "?."
07:16 - Elvis operator "?:"

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

00:00 - Введение
00:34 - Java switch
01:10 - Groovy switch
04:54 - switch bytecode
05:22 - Метод isCase
07:29 - Оператор in

В Groovy внесли изменения и в привычные нам конструкции циклов (в основном цикл for). Но на практике в функциональном стиле для коллекций в основном все равно будут использоваться замыкания (Closure). Поэтому начнем с самых простейших методов, которые можно использовать вместо циклов for. В последующих видео увидим, как и что сделано в различных структурах данных. 

00:00 - Введение
00:15 - Java loops
01:18 - Groovy index for loop
02:25 - Groovy foreach loop
03:32 - Методы upTo & downTo
04:50 - Методы times & step
06:06 - Класс DefaultGroovyMethods
07:39 - Класс CallSite

Разработчики Groovy решили объединить удобство инициализации массивов в Java и функционал интерфейса List. В итоге получилось действительно лаконично и удобно работать со списками. Более того, их обогатили новыми методами из очередей и теории множеств. Конечно же, добавилось много синтаксического сахара и новые операторы. В конце занятия вновь зайдем в bytecode чтобы понять, как все работает под капотом. 

00:00 - Введение
00:27 - Инициализация списков
01:32 - Чтения данных в списках
03:52 - Запись данных в списках
06:06 - Методы очередей
06:57 - Методы множеств
08:57 - Новые операторы
10:15 - bytecode

Map - это одна из лучших структур данных, которых придумало человечество. Но в Java довольно сложно их инициализировать, не так удобно читать и записывать данные. В Groovy конечно же попытались решить все эти проблемы и на видео мы как всегда продемонстрируем все новшество. И конечно же поговорим про новый spread operator. 

00:00 - Введение
00:24 - Инициализация Map
02:34 - Чтение данных в Map
05:12 - Запись данных в Map
05:34 - Новые метод subMap
06:52 - Новый оператор spread

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

00:00 - Введение
00:30 - Новая коллекция Range
01:10 - Инициализация объекта Range
01:55 - Методы класса Range
03:56 - Range символов
04:27 - Написание собственного Range
06:11 - Резюме

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

00:00 - Введение
01:03 - Object iteration methods
03:07 - Object iteration practice
05:47 - grep
08:30 - Резюме

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

00:00 - Введение
00:15 - Модификаторы доступа и поля в Groovy классах
03:00 - Конструктор Map
04:46 - Coercion
06:58 - Multiple assignment
08:28 - Spread operator
09:49 - Резюме

Как мы знаем, в Java нет множественного наследования, но возможно реализовывать множество интерфейсов одним классом. Споры о том, хорошо или плохо, наверное, не утихнут никогда. Тем не менее в Groovy ввели новое понятие Trait, который невероятно похож на интерфейсы с дефолтными методами, которые появились в Java 8, но позволяет еще и добавлять поля! А т.к. это обычный интерфейс в байткоде (мы в этом убедимся в видео), то получается, что мы все-таки можем имитировать множественное наследование. Также поговорим про разницу в JavaBeans и GroovyBeans specification. 

00:00 - Введение
00:15 - JavaBeans specification
01:05 - GroovyBeans specification
01:47 - Trait
04:30 - Trait bytecode
05:20 - Метод getProperties
06:30 - Аннотация @Mixin - deprecated
07:03 - Runtime mixins

Класс File, что мы когда-то проходили на курсе Java level 2 - является базовым для представления файла или директории на жестком диске. В Groovy решили взять его за основу для работы с потоками ввода-вывода и привнести довольно большой объем новых методов с помощью утилитного класса ResourceGroovyMethods (как они эти методы появляются в других классах вроде File - мы подробно обсудим еще в следующих видео). Более того, появилась довольно интересная концепции, чтобы не закрывать потоки ввода-вывода после их использования. Также на видео поговорим насчет преимущества использования unchecked exceptions. 

00:00 - Введение
00:19 - Класс File. Чтения данных
03:30 - Класс File. Запись данных
05:56 - Traversing
07:40 - Резюме

AST (Abstract Syntax Tree) - это ключевой момент в понимании того, как устроены большинство компиляторов современных языков программирования. На этом видео мы немного углубимся в них, чтобы понять, как это устроено все под капотом. А также как мы можем использовать аннотации, которые работают поверх AST, добавляя кучу разного кода перед тем, как AST преобразуется в байт код (Lombok, которые мы проходили на курсе по HTTP Servlets работает точно таким же способом - изменяет AST перед тем, как преобразуется в байт код). 

00:00 - Введение
00:40 - Groovy Parser
02:04 - Abstract Syntax Tree
04:36 - AST аннотации
06:14 - AST bytecode
07:06 - Исходный код @ToString
08:51 - Резюме

Как мы знаем, Groovy - это JVM язык, следовательно, он должен быть невероятно похож на Java, т.к. компилируется в байт код. Тогда каким образом можно было изменить на столько природу языка Groovy: привнести динамическую составляющую. Ведь Java - это чисто статический язык, и после компиляции невозможно добавить/изменить функционал в классах. А все на самом деле просто - добавлена специальная прослойка MOP (Meta Object Protocol), и все вызовы из Groovy классов проксируются через вспомогательные классы MOP. 

00:00 - Введение
00:27 - Динамическое программирование
01:09 - Meta Object Protocol
03:48 - Сравнение javac и groovyc
05:21 - Практика

Ключевое момент в понимании того, каким образом появляются новые методы в классах, которые не содержат их, или каким образом можно эти методы добавить в runtime или изменить их - это специальный класс MetaClass, который есть во всех классах, даже в Java Core. На видео сами попробуем создать свой MetaClass и добавим туда метод сторонних классов, чтобы лучше разобраться в этом. И конечно же рассмотрим основные уже существующие в Groovy реализации класса MetaClass. 

00:00 - Введение
00:35 - Создание CustomMetaClass
05:18 - Класс MetaClassImpl
05:56 - Класс ExpandoMetaClass
10:31 - Класс ProxyMetaClass
11:05 - Резюме

Хоть и кажется, что код на Groovy компилируется почти всегда, потому что присутствие методов и полей в классах определяется только в runtime, проходя через MOP, но тем не менее, нужно понимать, что происходит в том случае, когда все-таки какие-то методы и поля не нашлись в наших MetaClass. Для этого конечно же уже существует функционал - это методы propertyMissing и methodMissing. В видео на практике посмотрим, как можно использовать эти 2 метода для своих нужд. 

00:00 - Введение
00:56 - Метод methodMissing
03:23 - Метод propertyMissing
04:15 - Пример использования propertyMissing
05:27 - Пример использования methodMissing
08:02 - Резюме

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

00:00 - Введение
00:39 - Аннотация @Category
02:33 - Метод use
04:10 - bytecode
05:05 - Полная сигнатура @Category метода

Во второй части темы замыканий (Closure) мы увидим другую, более мощную сторону их. После чего мы не будем смотреть на них как просто аналог лямбда выражений в Java. Более того, эти возможности являются ключевыми в понимании устройства многих шаблонов проектирования в Groovy, особенно Builder. И конечно же ключевым в понимании DSL (Domain Specific Language), который мы будем рассматривать в отдельном видео. 

00:00 - Введение
00:25 - Поля thisObject, owner, delegate
02:40 - Closure bytecode
03:30 - Шаблон проектирования Delegate
05:14 - Поле resolveStrategy
07:15 - Метод with
08:03 - Разница между thisObject и owner
10:30 - 2 этапа closure: declaration и execution

Вот мы и дошли до практического занятия, где попробуем закрепить полученные знания с предыдущих лекций, особенно более сложные темы: динамического программирования и метаклассов, замыкай и их невероятной возможности делегировать вызовы другим объектам (owner, delegate). Также увидим, как можно использовать категории (Category) как альтернативный вариант, вместо изменения метаклассов.

00:00 - Введение
00:16 - Задача №1
05:28 - Задача №2. Решение №1
09:06 - Задача №2. Решение №2
12:10 - Задача №3
20:01 - Резюме

Одна из самых интереснейших тем в Groovy, которую мы по крайней мере можем теперь освоить, оглядываясь на весь пройденный материал до этой темы. И конечно же, именно понимание DSL открывает путь к успешному усвоению других инструментов, с которыми столкнется каждый Java разработчик - это Gradle и Jenkins. На видео создадим свой Email DSL для конструированию объекта по отправке email. 

00:00 - Введение
00:53 - Разница между кодом и DSL
04:10 - Реализация Email DSL
12:00 - Тестирование функционала
12:58 - Аннотация @DelegateTo
13:49 - Резюме

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

00:00 - Введение
00:22 - Что мы узнали после прохождения курса
04:00 - Что еще нужно освоить
04:54 - Скорость работы Groovy в сравнении с Java
05:55 - Резюме