Building Applications with Spring 5 and Kotlin: Build scalable and reactive applications with Spring combined with the productivity of Kotlin

Your mission, as we mentioned, will be making a real-world application. What can be a better learning path than building real things from scratch through to production deployment? Our real-world application example will have a real theme!

We will create a REST application that will represent the application programming interface (API) for other applications. The theme for our application will be simple: management for user Notes and TODOs.

Imagine that there is a real-world mobile application that manages all these Notes and TODOs. That application will need a REST API so that all the data is synchronized to the backend. The story is simple. The user creates a Note or TODO. The user's mobile application then, at some point, does the synchronization. After some time, the user updates the content in it. Again, data is synchronized with the remote backend instance. Then, after a year, the user buys a new device that has a plain mobile application running. Luckily, the mobile application will synchronize with the remote backend instance again and get all the Notes and TODOs the user created.

So, what will this REST API do?

It will expose to the end user API calls for all Create, Read, Update, and Delete (CRUD) operations. The data we create or modify will be stored in the persistence layer. In our case, that will be MySQL database. Using Spring Security, we will create user roles so certain user profiles can do various things, such as creating the other users or modifying the main application content. To make things more interesting, we will create microservices responsible for various tasks.

Before we deploy, we will first test our code with the proper tests. We will also write unit tests. All tests will cover some of the core functionality so that our application is sufficiently stable to be deployed. We will deploy to Apache Tomcat and to Amazon AWS Elastic Beanstalk.

Before we start with the implementation, we will separate our code into independent entities. Each entity will cover a single responsibility and therefore will be implemented when we cover a certain Spring functionality.

We will start with the main classes that will represent the data we will actually handle: Notes and TODOs. Then we will describe user-related stuff: the users themselves and the roles we plan to assign to them. Later, when we actually implement most of them, we will introduce some new entities to cover additional responsibilities. This will be explained in Chapter 3, Building Your First Spring RESTful Service with Kotlin.

For every project you do, for big and complex projects, and for small ones too, planning is crucial! We will plan our development according to the chapter structure of this book. So, some stuff will be done first and some later. As you have probably realized, user-related functionalities will be provided when we touch on Spring Security. Until then, we will be focused on the main data entities and their relationship with Spring Framework and API clients as well.

Before you get into the deep implementation, it would be wise to plan your work first. As we already did, you should identify all your entities and the relations between them. You must be aware of potential hard connections between them. The best scenario is that each entity is completely independent and not aware of others. In our case, the user entity does not have any awareness of our main data entities, Notes, and TODOs, and vice versa.

Then, if we put all this on paper, we can consider what environments we will have. A common practice is that we have development, staging, and production environments. For bigger projects, sometimes a preproduction environment is also used. In our case, we will have a local development environment, too. The local development environment will be the one we will use for all these exercises. We will use our local working machines running an instance of MySQL and our Spring Framework application.

You must plan how will you deploy the application. For example, an application can run on Apache Tomcat or Amazon AWS. These are not the only options available. Depending on your needs, you will choose a proper deployment platform and deployment scenario. We will discuss this in more detail in Chapter 10, Project Deployment.

Finally, it's time to prepare our working environment. We will prepare all the software needed to develop and run our application. For this process, we will need the following:

For a proper development machine, you can use any computer having, for example, an i5 processor (or more powerful) with at least 8 GB of RAM. These are the main characteristics. You can do your development on Microsoft Windows, Linux, or macOS. All the development mentioned in this book was done on macOS Sierra (version 10.12.6).

$ git config --global user.name "Your Name"
$ git config --global user.email "[email protected]"

$ git -version 
git version 2.7.0 (Apple Git-66) 

$ sudo apt-get update 
$ sudo apt-get install git

$ git -version

git version 2.9.2

$ git config --global user.name "Your Name" 
$ git config --global user.email "[email protected]"

$ sudo dnf install git 
//or
$ sudo yum install git

$ git -version

git version 2.9.2

$ git config --global user.name "Your Name"
$ git config --global user.email "[email protected]"

$ sudo apt-get update
$ sudo apt-get install libcurl4-gnutls-dev libexpat1-dev gettext libz-dev libssl-dev asciidoc xmlto docbook2x

$ git clone https://git.kernel.org/pub/scm/git/git.git

$ make all doc info prefix=/usr
$ sudo make install install-doc install-html install-info install-man prefix=/usr

$ sudo dnf install curl-devel expat-devel gettext-devel openssl-devel perl-devel zlib-devel asciidoc xmlto docbook2X

$ sudo yum install epel-release
$ sudo yum install curl-devel expat-devel gettext-devel openssl-devel perl-devel zlib-devel asciidoc xmlto docbook2X

$ sudo ln -s /usr/bin/db2x_docbook2texi /usr/bin/docbook2x-texi

$git clone https://git.kernel.org/pub/scm/git/git.git

$ make all doc prefix=/usr
$ sudo make install install-doc install-html install-man prefix=/usr

$ rpm -ihv package_you_downloaded.rpm

$ java -version

$ java -version
java version "1.8.0_144"
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)

Starting IntelliJ for the first time

You have installed IntelliJ; now it is time for the first run. You will be asked to do some configuring. Don't worry, everything is simple and easy. Just follow the instructions:

1. Launch IntelliJ and wait until the Complete Installation dialog appears. Choose Don't import settings and continue by clicking on OK.

 

2. Next, you will be prompted to select the UI theme. You can choose between the default theme and the Darcula theme. We recommend that you use the Darcula theme:

3. In the next section, disable any plugins that are not required:

4. In the next step, you are prompted to download additional plugins:

5. Finally, you can start the project! The setup is complete, as shown in the following screenshot:

Installing Spring 5

Before installing or running Spring 5, we need to install Kotlin, since this is our primary programming language for the project:

1. Open IntelliJ IDEA and choose Configure | Plugins, as shown in the following screenshot:

2. In the search field, type Kotlin:

3. Click on the Install JetBrains plugin... button.

 

4. From the list that appears, choose Kotlin.
5. If you do not already have Kotlin installed, you will see a green Install button. Click on it, otherwise click on the Update button, as shown in the following screenshot:

6. Wait until the installation or update process completes:

7. When the installation is finished, click on the Restart IntelliJ IDEA button:

If the Restart IntelliJ IDEA button does not restart your IDE, do it yourself manually.

Your IDE is ready for development. It is time to finally set up Spring 5! You can use Spring in the same way as any standard Java library. Simply include the appropriate Spring library files in your classpath. Spring does not require any special tool integration, so you can use any IDE or text editor! As you already know, we will stick to IntelliJ IDEA. You can run and debug Spring applications as you would any other Java application.

Spring can be used through Maven or Gradle. It is up to you to choose which suits you better. We will use Gradle in our development but we will give examples of Maven too.

Maven installation

The recommended way to get started using Spring Framework in your project is with a dependency management system. Take a look at the following Maven example:

<dependencies> 
    <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-context</artifactId> 
        <version>5.0.0.RC4</version> 
    </dependency> 
</dependencies><repositories> 
    <repository> 
        <id>spring-milestones</id> 
        <name>Spring Milestones</name> 
        <url>https://repo.spring.io/libs-milestone</url> 
        <snapshots> 
            <enabled>false</enabled> 
        </snapshots>      
    </repository>  
</repositories>

Gradle installation

Gradle installation requires less code, as the following snippet shows:

repositories { 
    maven { 
        url 'https://repo.spring.io/libs-milestone' 
    } 
}  
dependencies { 
    compile 'org.springframework:spring-context:5.0.0.RC4' 
 
} 

Installing Postman

To try out our API calls, we will need Postman. Postman is a complete toolchain for API development. Postman is designed from the ground up to support the API developer. It offers us an intuitive user interface to send requests, save responses, add tests, and create workflows.

To get Postman, open https://www.getpostman.com/postman and choose your OS.

Microsoft Windows installation

The following are the steps to install Postman in Microsoft Windows:

1. Download the setup file
2. Run the installer
3. Follow the setup instructions

Linux installation

To simplify the installation process, we recommend that you install it through the Google Chrome store. Search for Postman and install it:

macOS installation

Once you have downloaded the Postman-archived application, extract it, then drag the file to the Applications folder. Double-click on Postman to open the application.

Postman is installed. Run it and take a look at its UI. We will not go into details on how to use it. It is enough to play a bit. Most of the options are self-explanatory. Enjoy!

The following screenshot shows the Postman application running on macOS:

We have installed the IDE and Spring Framework. It is time to start working on our project. We will develop a REST application API for Notes and TODOs. This is a tool that everybody needs. We will give it a name: Journaler API. Journaler API will be a REST application capable of creating Notes and TODOs with reminders. Many different applications, such as mobile ones, will be synced to our backend instance running this REST application.

The first step in development is initializing a Git repository. Git will be our code versioning system. It is up to you to decide whether you will use GitHub, BitBucket, or something else for your remote Git instance. Create your remote repository and keep its URL ready along with your credentials. So, let's start!

The following are the steps to set up Git:

$ git init .

Initialized empty Git repository in <directory_you_choose/.git>

$ vi notes.txt

$ git add .
$ git commit -m "Journaler API: First commit"

[master (root-commit) 5e98ea4] Journaler API: First commit
 
1 file changed, 1 insertion(+)
 
create mode 100644 notes.txt

$ git remote add origin <repository_url>

$ git remote -v

$ git push -u origin master

These are exciting times! We are preparing to dive deep into the depths of Spring Framework. We are practically ready! We have set our environment up! We have installed Git, Java JDK, and IDE, shown you how Spring Framework is installed, and finally installed Postman. We skipped the MySQL installation for now but we will get back to it once we introduce you to Spring data.

Dear reader, we have come to the end of the first chapter. We have learned how to set up and configure the environment for development. In the next chapter, we will make our first real steps into Spring Framework. We will explain what Spring is and why you need it! We will write some code, run it, and trigger our first API call. So, get ready!