The Complete Apache Groovy Developer Course

In this lecture we are going to talk about what we cover in this section. This section is all about getting started, setting up your development environment and making sure you know how to use the tools you have at your disposal. 

In this tutorial we are going to install Groovy on Mac OSX by using one of my favorite tools. The Software Development Kit Manager (SDKMAN) is a great tool for managing parallel versions of software. If you are on Mac OSX you can still install Groovy manually but quite honestly I don't know why you would.

In this exercise you will create 3 different Hello World scripts.

So how do you think you did with that exercise? Now that you have had some time to take a look at it I want to go through a quick review and let you know how I would have solved that problem.

Time to review what we learned in this section.

In this lecture we are going to talk through how to use import statements to import packages and classes into your program. 

In this lecture you going to create your own class and we are going to have a few rules for you to follow.

In this lecture we are going to review the previous exercise on creating your own class.

AST Transformations are awesome. In this exercise we are going practice using a few.

In this lecture we are going to review the exercise on AST Transformations.

In this lecture we are going to look at some of the basic operators that you will come across in Groovy.

We are going to cover what we learned in this section

In this lecture I just want to talk briefly about what we are going to learn in this section.

In this lesson we are going to talk about primitive data types in Java. To understand data types in Groovy we need to understand data types in Java

In this lecture we are going to talk more about Groovy data types. In Java every variable needs to be declared with a type and this is one place where Groovy is very different.

All about data types

In this lecture we are going to cover some of scenarios you are going to run into while working with numbers in Groovy.

In this lecture we are going to talk about this concept of Operator Overloading. We are going to look through the documentation and see what operator overloading is available to us and walk through some demos. 

In this exercise we are going to learn how to implement operator overloading on our own classes.

In this lecture we are going to review our operator overloading exercise.

In this lecture we are going to look at working with Strings in Groovy. There are different ways to create Strings based on our needs and we will cover most of them here.

In this lecture we are going to cover the basics of regular expressions. Java has had support for regular expressions (or regex as it's often referred to as) since 1.4. These are a representation of a search pattern used to scan and match for text. While you can use them in Java there are certain situations where the become very complicated. Groovy adds three very helpful methods to the API. In this lecture we are going to cover those, some basics about constructing patterns and a short demo that will bring everything together for us.

In the last section we took a look at some basic data types in Java & Groovy. In this section we are going to dive into some complex data types also known as collections. If you have done any Java programming in the past you know that working with collections hasn’t always been easy. In fact Groovy took something complex in Java and made it easy to work with and that is one of the main reasons I took a look at Groovy in the first place. In this section we are going to take a look at ranges which might be new to some developers but they are very useful and easy to work with. We will also look into maps and lists but thanks to some GDK enhancements they also become very easy to work with.

In this lecture we are going to take a look at our first complex data type called a Range. Ranges allow us to define a list or "range" of items and move through them. 

In this lecture we look at another data type called a list. Lists allow us to create lists of things and there is an easy to use API for manipulating these lists. 

In this lecture we are going to look at the final data type of this section called a Map. A map allows us to create key / value pairs of data.

We are going to review the quiz on using collections.

We are going to begin our introduction to closures in this section. You can start to do some really cool things with closures and they are a fundamental concept in learning the Groovy programming language. 

In this section we are finally going to dive into Closures. You aren’t going to get very far in Groovy before you start running into Closures. They are everywhere and a pretty big part of the language. In fact they are probably the key feature that has made Groovy as popular as it today. That is why this section is extremely important to understand and I hope you will take the time to really understand we go over here.

So what is a closure? A closure is just like a method except that it is a first class citizen of the language. When I have a method in a class we give it a name, it takes some arguments and it performs some actions. A closure will do the same thing but unlike a method a closure is an object and can be used or passed around your program.

In this lecture we are going to introduce you to closures. We will walk through how to create them and some of the basic syntax we use to construct closures. 

A closure can accept parameters just like a method can. In this lecture we are going to look at all of the different ways a closure can accept parameters. 

This is a quiz about the basics of using closures.

In this lecture we are going to dive into the documentation and look at some of the different methods we can perform on collections. We are also going to look at how to use a lot of these. These methods should start to make a lot more sense now that we understand how closures work.

In Groovy, currying refers to the concept of partial application. Currying in Groovy will let you set the value of one parameter of a closure, and it will return a new closure accepting one less argument.

In this lecture we look at what scopes are available to us in a Closure. The delegate of a Closure is an important concept and helps set them apart from lambdas. 

In this exercise we are going to put what we learned in this section to the test. We have a bunch of exercises that should help us understand how to use closures a little better. 

In this lecture we are going to review the exercise Using Closures. 

In this lecture we will talk about our introduction into control structures. 

Before we dive into the conditional structures like if, if / else or when we need to understand what the Groovy Truth is. This is because the expressions that are defined in those control structures need to evaluate ot a boolean and there is a fundamental difference how we handle this in Groovy compared to Java.

Understanding how Groovy evaluates expressions as truth is important. In this quiz we are going to give you a bunch of examples and you need to tell me if it evaluates to true or false. 

In this lecture we dive into the conditional structures that you are going to use in Groovy.

• if
• if/else
• if/else if/else
• ternary / elvis
• switch
• in

In this lecture we are going to look at the different looping constructs available to us in Groovy.

In this lecture we are going to get our first introduction to exception handling in Groovy. Exception handling in Groovy is pretty similar to Java with one big fundamental change and its a change I LOVE.

We are going to have a quick exercise to cover what we learned in this section.

Did you like this exercise? It was pretty short and sweet but we are starting to write more complete classes and this is really starting to get fun right? 

What is Object Oriented Programming (OOP) and why should I care about it? What are some of the concepts that we are going to cover in this section. Please remember that people have written books on this subject alone so we won't cover everything. This is an introduction to the terms and concepts to make you more familiar with them so you can spot them and use them. 

We have talked about classes throughout this course but we really haven't had a chance to dive into the details. In this lecture we talk about how to create a class, declare fields and local variables. 

Now that we have our class created and we know how to created fields it's time to move on to methods. In this lecture we are going to cover how to create and call constructors and methods. 

In this lecture we are going to use IntelliJ and learn all about packages. When we create classes we need a way to organize them so our classes remain maintainable and packages give us that ability. 

We are going to review the basic building blocks for creating classes. 

In this lecture we are going to talk about inheritance. When you have behavior that might be common to many classes we create a class to hold this functionality and extend this "base" class from our other classes. 

A JavaBean is just a standard

- All properties private (use getters/setters)
- A public no-argument constructor
- Implements Serializable.

    Java provides a mechanism, called object serialization where an object can be represented as a
    sequence of bytes that includes the object's data as well as information about the object's
    type and the types of data stored in the object.

- Create a Java Bean
- Equivalent Groovy Bean
- Look at a Groovy Bean under the hood
- How to use Groovy Beans
- How to write your own getters / setters
- Direct field access

Metaprogramming is one of the highlights of Groovy. 

The MOP (Meta Object Protocol) is a really big concept to understand when it comes to MetaProgramming. In this lecture we are going to define the MOP and explain what it is and how it is used. 

Now that we have a little bit of an understanding of what the MOP is it's time to dive in a little further. We are going to learn how to customize the MOP using different hooks. 

Every single class has an associated MetaClass. The MetaClass contains all of the methods & properties your class contains. Where the dynamic nature of Groovy comes into play is by manipulating that MetaClass and not the concrete class. 

Just some basic question about what we are learning in this section.

Using the metaclass to add dynamic capabilities to our program is usually going to be the way to go. Sometimes we might prefer an alternative method that is a little more confined and not so application wide. In this lesson I want to take a look at this problem and show how categories help us solve it. There are also a few built in categories in the language and we will look at a demo of one today.

In this lecture we are going to look at a pattern called the Intercept / Cache / Invoke Pattern. This is a pretty solid performance pattern that we should be taking advantage of when we start dealing with missing methods. 

We are going to review the Runtime Metaprogramming exercise

We are to look at some AST Transformations that allow us to change the code at compile time.

A Class annotation is used to assist in the creation of toString() methods in classes. The @ToString annotation instructs the compiler to execute an AST transformation which adds the necessary toString() method.

Class annotation used to assist in creating appropriate equals() and hashCode() methods.

The @TupleConstructor annotation instructs the compiler to execute an AST transformation which adds the necessary constructor method to your class.

The @Canonical annotation instructs the compiler to execute an AST transformation which adds positional constructors, equals, hashCode and a pretty print toString to your class. There are additional annotations if you only need some of the functionality: @EqualsAndHashCode, @ToString and @TupleConstructor. In addition, you can add one of the other annotations if you need to further customize the behavior of the AST transformation.

Class annotation to make a singleton class. The singleton is obtained through normal property access using the singleton property (defaults to "instance"). Such classes can be initialized during normal static initialization of the class or lazily (on first access). To make the singleton lazy use @Singleton(lazy=true). Lazy singletons are implemented with double-checked locking and a volatile backing field. By default, no explicit constructors are allowed. To create one or more explicit constructors use @Singleton(strict=false).

A class annotation used to make a class Comparable by multiple Comparators.

The @Immutable annotation instructs the compiler to execute an AST transformation which adds the necessary getters, constructors, equals, hashCode and other helper methods that are typically written when creating immutable classes with the defined properties.

This will let the Groovy compiler use compile time checks in the style of Java.

This will let the Groovy compiler use compile time checks in the style of Java then perform static compilation, thus bypassing the Groovy meta object protocol.

The @Builder AST transformation is used to help write classes that can be created using fluent api calls. The transform supports multiple building strategies to cover a range of cases and there are a number of configuration options to customize the building process. In addition, a number of annotation attributes let you customise the building process. Not all annotation attributes are supported by all strategies. See the individual strategy documentation for more details. If you're an AST hacker, you can also define your own strategy class. The following strategies are bundled with Groovy:

• SimpleStrategy for creating chained setters
• ExternalStrategy where you annotate an explicit builder class while leaving some buildee class being built untouched
• DefaultStrategy which creates a nested helper class for instance creation
• InitializerStrategy which creates a nested helper class for instance creation which when used with @CompileStatic allows type-safe object creation

We looking at a lot of AST Transformations in this section. Now I want you go through the documentation and find one that we didn't look at and see if you can get it to work on your own.

Exercise Review - Find an  AST Transformation that we didn't cover and use it.