Building Spring Boot Applications with the Kotlin Programming Language

Table of contents

1. INTRODUCTION
   1. Introduction, and install Hadoop on your desktop!
   2. What is Kotlin?
   3. Installing IntelliJ
   4. Configuring IntelliJ
2. WORKING WITH STRINGS
   1. Creating a new project in Kotlin
   2. Variable declaration syntax
   3. Inferring variable types and println
   4. Using String templates
   5. Multiple line strings
3. OTHER VARIABLE TYPES
   1. Using the Double and determining class types
   2. The Int data type
   3. Other data types
   4. Casting in Java
   5. Casting in Kotlin
   6. Chapter review
4. NULLABLE VARIABLES
   1. Creating variables that can contain a null value
   2. Methods that work with nullable parameters
   3. The null-safe and non-null asserted operators
   4. The nothing object type
5. FUNCTIONS
   1. The function syntax and the Unit object
   2. Creating and calling top level functions
   3. Single expression functions
   4. Using named parameters when calling functions
   5. Other aspects of functions in Kotlin
6. CLASSES
   1. Project structure and packages
   2. The class declaration and class level attributes
   3. Instantiating a class, and accessing the class attributes
   4. Creating a simple constructor
   5. Secondary constructors
   6. Alternative class design
   7. Overriding getters and setters
   8. Functions within a class
   9. Static functions
   10. Data classes
7. PRACTICAL EXERCISE 1
   1. Explaining the challenge
   2. Solution walkthrough
8. THE IF EXPRESSION AND OBJECT EQUALITY
   1. The If keyword as an expression
   2. Using if to do a null-safe check
   3. The let function
   4. Object equality and the when expression
9. RANGES AND LOOPING
   1. The While loop
   2. Using for to loop through a collection
   3. Destructuring with a for loop
   4. Looping with the Range object
10. COLLECTIONS
    1. Mutable collections with immutable variables
    2. Immutable lists
    3. Mutable lists
    4. Maps and sets
    5. Working with Arrays
11. PRACTICAL EXERCISE 2
    1. Explaining the challenge
    2. Solution walkthrough
12. EXCEPTIONS AND TRY CATCH BLOCKS
    1. Exceptions are unchecked
    2. Throwing exceptions
    3. Try as an expression
    4. Use as an expression (try with resources)
13. TESTING
    1. Using Junit with Kotlin
    2. The Kotlin test assertions
    3. Testing for exceptions
14. INTERFACES AND EXTENDING CLASSES
    1. Creating and implementing Interfaces
    2. Class inheritance
    3. Creating custom exceptions
    4. Extension functions
15. JAVA INTEROPERABILITY
    1. Instantiating classes and providing values to non-nullable variables
    2. Using data classes
    3. Using immutable lists
    4. Exception handling
    5. Using static functions
    6. Importing a Kotlin jar into a Java project
16. GETTING STARTED WITH SPRING BOOT
    1. Creating a project with the Spring Initializer
    2. A hello world controller
    3. Auto restarting an application
    4. Overview of the case study we’ll be working on
    5. Creating views and backing beans
    6. Connecting views to controller functions
    7. Adding services
    8. Posting data to a controller
    9. Dependency injection
    10. Revisiting backing beans
17. FUNCTIONAL PROGRAMMING
    1. Functional programming overview
    2. Methods that take function parameters - the Java way
    3. Methods that take function parameters - the Kotlin way
    4. Functional programming with lists
    5. Filter and flatmap
    6. Reduce and Fold
    7. Working with Maps
18. GETTING STARTED WITH HIBERNATE
    1. Adding the Hibernate dependencies
    2. The challenge of creating entities
    3. Persisting data to a database
19. PRACTICAL EXERCISE 3
    1. Step 1 - explaining the challenge
    2. Solution Walkthrough
    3. Mappings between entities
    4. Upgrading the view
    5. Step 2 - explaining the challenge
    6. Solution walkthrough
    7. Step 3 - explaining the challenge
    8. Solution walkthrough
20. REFLECTION
    1. The concept of reflection
    2. Inspecting properties and functions
    3. A practical use for reflection
    4. Thank you and goodbye