Full Stack Kotlin Development
3.3 (15 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
90 students enrolled

Full Stack Kotlin Development

Leverage the power of Kotlin to build full-stack applications
3.3 (15 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
90 students enrolled
Created by Packt Publishing
Last updated 12/2017
English
English [Auto]
Current price: $86.99 Original price: $124.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 6 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Create a Spring application with Spring 5, Spring Boot 2, and Kotlin with the help of Kotlin Gradle script
  • Create a Kotlin front-end application using React and Redux with the help of Webpack
  • Get to grips with full-stack application development with a single language
  • See modern JVM application architecture and its ecosystem
  • Understand modern web application front-end development with static type safety, including build processes and communication patterns
Course content
Expand all 42 lectures 06:09:03
+ Kotlin Spring Setup and Build Processes
7 lectures 50:17

This video provides an overview of the entire course.

Preview 05:55

Setting up a Kotlin project using Gradle and Kotlin Gradle DSL.

• Introduce Gradle Kotlin build script to project
• Create hello world Kotlin main class
• Run Kotlin application from the command line using Gradle

Getting Started with Kotlin and Gradle
07:49

Introduce Spring Boot 2 dependencies to a Kotlin project.

• Add Spring Boot 2 dependencies to Gradle build script
• Set up and configure Spring context
• Create our first Spring Bean

Spring Boot 2 Configuration
08:26

Define Spring Beans using the new Spring 5 functional bean definition and Kotlin DSL for functional beans.

• Introduce new Spring 5 feature: functional bean definitions
• Create externalized configuration for modular monolith application in mind
• Refactor away from annotation based Spring configuration and bean definition

Functional Spring Beans with Kotlin DSL
07:33

Make Kotlin and Spring play well together when Kotlin classes are final and Spring needs non-final classes.

• Look at decompiling Kotlin to Java with Intelli
• Discuss Spring class extension via CGLIB and its need for non-finality
• Introduce Kotlin Spring plugin to automatically open classes annotated with Spring annotations

Spring and Kotlin, Opening Our Classes for Extension
05:44

Setting up a properly architected project by creating a multi module Gradle setup.

• Modify Gradle build script to be able to manage multiple sub modules
• Create scoped sub modules to have their own Gradle build files
• Extract source files to their correct modules to have a bounded context

Componentizing Our Spring Project with Gradle Modules
08:20

Hiding a too widely visible implementation details from external APIs with modules and Kotlin `internal` visibility modifier.

• Discuss a proper architecture on monolithic applications to provide modifiability and good bounded context
• Extracting interfaces to expose clean API and hiding our implementations with Kotlin Internal visibility modifier
• Modifying injected beans to be interfaces instead of classes

Component and Layer Scoping with Kotlin Visibility Modifiers
06:30

Now that you are done with the videos of section 1, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Kotlin Spring Setup and Build Processes
6 questions
+ Spring Web with Kotlin
4 lectures 35:06

Serving content from a web server with Spring Boot 2 and Kotlin.

• Set up dependencies for Spring web
• Create our first Spring RestController
• Start up the application and serving content from our first API endpoint

Preview 08:17

Create HTML page with Kotlin HTML DSL and serving that to the browser.

• Add needed dependencies to use Kotlin HTML DSL
• Modify Spring controller to return HTML string
• Create our first HTML page with Kotlin HTML DSL and serving it via RestController endpoint

Kotlin HTML DSL and Spring Controllers
08:05

Modify existing endpoints to be reactive and use new Spring 5 reactive functional web endpoint handling.

• New Spring 5 feature: Reactive Web, aka Spring Webflux
• Refactor old style annotation based controller endpoint to use new functional Kotlin Route builder
• Modify endpoint response and application context setup to work with functional routes

Kotlin DSL for Functional Spring Controllers
08:34

Define restful API to serve data to our frontend.

• RESTful APIs with reactive Spring
• Separate APIs and views to conform best practices. Extracting extension functions as helpers
• Add static resources to call our REST API and print out responses

View and REST API Organization and Generic Web Application Structure
10:10

Now that you are done with the videos of section 2, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Spring Web with Kotlin
8 questions
+ Business Logic Layer and Data Integrity on API's
3 lectures 29:25

Handling invalid request coming in from the server.

• Introduction model DTOs and validation DTOs and Hibernate Validator
• Add annotation based validation to Kotlin data classes
• Modify functional API routes to respond based on validation results

Validating Spring REST Endpoints
10:30

Handling requests, errors and exception in functional Spring routes.

• Extract handlers from our Spring routes
• Create a filter function and add logging to our requests
• Extend Spring frameworks exception handling to respond with our desired responses and response codes

Handlers and Filters for Web Layer Requests
09:08

Keeping models separate between components and web facing API layer and keeping our data model hidden from the user.

• Add extension functions to handle model transformations
• Modify our handlers to control the data flow between components and web layer
• Create our first stateful web application by using DTO transformations and in-memory object to maintain state

Managing State Between Web and Business Logic Layer
09:47

Now that you are done with the videos of section 3, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Business Logic Layer and Data Integrity on API's
6 questions
+ Spring Data with Kotlin
4 lectures 35:11

Choosing a correct Spring data implementation and a database.

• Add Spring data dependency to Gradle build
• Choose the correct database, relational versus NoSQL
• Add database driver dependencies to the Gradle build files

Introduction to Spring Data Dependencies
09:14

Creating entities to model database structure in Spring Kotlin application.

• Add dependency to Kotlin JPA plugin
• Create entity data class and add entity annotations to the class
• Set up database and generate tables based on JPA entities

Modeling JPA Entities with Kotlin Data Classes
05:59

Create a connection to database and save our first data

• Implement Spring data repository interface
• Modify application configuration to contain repository interface
• Modify services to use data repositories to create first database records

Spring Data Repositories and Accessing Datasource with Spring Data Library
08:58

Insert and edit database records, querying complex structures from the database

• Define separate service functions for querying and insert database records
• Introduction to Spring data query methods and query annotations
• Implement automatic row mapping to DTOs with Spring data

Handling Database Records, Querying and Inserting
11:00

Now that you are done with the videos of section 4, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Spring Data with Kotlin
8 questions
+ Spring Security
3 lectures 25:14

Pulling in correct dependencies to secure our application and configuring Spring Security.

• Add Spring security dependencies to the application
• Create a module to handle security
• Configure Spring security to prevent users from accessing our endpoints without auth

Configuring Spring Security
08:12

Creating user entity and services to map local users to Spring security users.

• Create a local model to hold user information
• Implement services and repositories to retrieve data
• Modify security configuration to use local user data

Modelling Authentication Entities and Users
07:25

Implementing custom service to check for authentication and creating login form

• Creating a service to handle authorization
• Modifying Spring security configuration to retrieve injected paths instead of hard coding paths
• Creating a authentication endpoint and login form

Custom Authorization Services and Auth Through Frontend
09:37

Now that you are done with the videos of section 5, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Spring Security
6 questions
+ Communicating with External Services
3 lectures 24:44

Choosing a correct rest client to work well with our backend application and Spring reactive architecture.

• Discuss the considerations into account when choosing a rest client
• Set up dependencies to retrieve external data with Spring WebClient
• Configure Spring WebClient using @Value annotation for path setup

Choosing and Setting Up a Restful Client
08:20

Choose the correct parameters and set up response handling to external API call.

• Investigate Github API endpoint response types
• Set up Spring WebClient with correct headers to fetch information
• Create DTOs and map external response into our DTO objects

Asynchronous Communication with External APIs
08:10

Using streaming data from WebClient and combining that with non-reactive data coming from the frontend

• Convert the frontend payload to a reactive stream
• Combine streams from external API call and frontend payload, creating a combined object
• Save the combined object to a database and respond with enhanced response DTO

Saving External Responses to the Database
08:14

Now that you are done with the videos of section 6, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Communicating with External Services
6 questions
+ Kotlin Frontend Module and Build Processes
4 lectures 31:31

Creating a module for frontend and setting up Kotlin to compile to JavaScript.

• Create a new frontend Gradle module to host frontend specific code
• Set up dependencies for Kotlin frontend build
• Configure Kotlin 2 JS plugin

Kotlin 2 JS Gradle Plugin and Gradle Kotlin DSL
07:41

Compiling Kotlin to JavaScript and creating frontend artifacts.

• Create Kotlin hello world application
• Use Gradle to build Kotlin frontend artifacts
• Add Kotlin Stdlib to frontend build and serve them via static web page

Building Kotlin JS and Generating Frontend Artifacts
07:25

Looking how to link backend and frontend builds together and how Kotlin communicates with native JavaScript.

• Kotlin dynamic keyword and external class definitions
• Call the external functions from Kotlin and write JavaScript in Kotlin
• Communicate with Kotlin application backend with XHR

Kotlin and JavaScript Interoperability
06:53

Creating a single frontend artifact and increase the velocity of Kotlin frontend development.

• Configure Kotlin frontend plugin for the application
• Add dead code elimination to remove unused JavaScript lines
• Run the frontend with Webpack and make use of hot reloading

Setting up Webpack for Bundling and Development Flow
09:32

Now that you are done with the videos of section 7, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

Kotlin Frontend Module and Build Processes
7 questions
+ React Architecture with Kotlin
2 lectures 17:31

Adding React bindings to be able to use React with Kotlin.

• Create a package for React bindings
• Port bindings to work with Kotlin application
• Investigate React binding implementations and how they map to React library

Kotlin Bindings for React Library
08:00

Creating a React application with Kotlin.

• Create a react component with Kotlin
• Set up application backend to serve HTML container to bind our component
• Implement multi-component React structure with Kotlin

React Application Entry Point and Component Structure
09:31

Now that you are done with the videos of section 8, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

React Architecture with Kotlin
4 questions
+ React View Creation
3 lectures 25:50

Understanding React component lifecycle and high level state management.

• Look at React component lifecycle methods
• Use lifecycle methods to modify state
• React state management and making renderer know state has changed

React Component Lifecycle and State
09:18

Handling React component hierarchy with Kotlin.

• Choose location for state and manage state changes
• Handle state changes from child components, action callbacks
• Make child components aware of changed state

Communication Between React Components
08:15

Handling routing in React applications.

• Introduce a listener to keep track of URL
• Render components conditionally based on URL
• Create links to move back and forward in application

Creating Multi-View React Applications
08:17

Now that you are done with the videos of section 9, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

React View creation
7 questions
+ React State Management
4 lectures 41:05

Understanding React state management and how to handle frontend application state in React world.

• Identify entry point and shape of application data
• Determine the container React components that manage state
• Create a model to contain application state and extract state and inject it into our components

Extracting Application State to an External Store
10:58

An overview of the Flux architecture recommended by Facebook to be used with React.

• Overview of Flux architecture and how the application state flow through it
• Introduction to simplified Flux implementation Redux
• Differences between pure Flux and Redux

React and Flux Architecture
06:18

Creating Redux bindings and adding them to a Kotlin React application

• Add Redux dependencies to frontend module
• Create type safe Redux wrappers for Kotlin
• Create a Redux store and dispatching actions

Redux Bindings for Your Kotlin React Application
11:33

Creating a React application with connected components using React, Redux and Kotlin

• Add React-Redux to frontend module
• Create Kotlin bindings for React-redux
• Connect React components to Redux store

Combining React, Redux and Kotlin with Connected Components
12:16

Now that you are done with the videos of section 10, let’s assess your learning. Here, are a few questions, followed by 4 options, out of which 1 is the correct option. Select the right option and validate your learning!

React State Management
7 questions
Requirements
  • Back-end and front-end developers are a different breed
Description

Kotlin brings many advantages to Java developers. Spring framework has taken Kotlin as one of their supported languages, and that makes Kotlin a perfect pairing with Spring for web application development. A strongly typed language like Kotlin brings safety to Javascript development. Creating a React application with Kotlin gives developers superior IDE support and type safety of a statically typed language.

This course will take you through the development of a full-stack application with Kotlin. First, we’ll create a back-end Spring MVC application with Kotlin. We’ll show you a generic Spring framework structure, how it maps to Kotlin, and how to enhance our application with Spring’s brilliant data access, security, and web service support.

Later, the course walks you through React application development with Kotlin. We’ll touch on the overall React application structure, data flow, and communication with the server over XHR. In the third volume, we’ll look at both back-end and front-end architecture and give you some ideas on how to make a seamless full-stack application with enhanced server-side rendering, data sharing between layers and reactive programming around Spring framework’s new reactive capabilities.

About The Author

Jussi Hallila is a Kotlin fanatic living in Ireland. As a Finland native, he is naturally a hockey fan and is always keen to discuss Linux and mock Apple, and he also gives lectures on open source.

Jussi has been in the software development game for over ten years and has been working with multinationals as well as small start-ups. His experiences among the development sphere have ranged from full back-end heavy Java development and implementing DevOps practices to the most hipsterish implementations of the newest of the new front-end frameworks. He has extensive experience developing with Spring, Vaadin, React, and Vue.Js, and advocating Kotlin server-side usage.

When he is not creating courses or tasting craft beers, Jussi works as the head of front-end development in VSware, creating the most innovative SAAS-based school management software. He also provides consulting, training, and software development services through his company, Ilities co.

Who this course is for:
  • The course is for professionals involved in web application development, and those who are working on a JVM back-end application and using untyped JavaScript as their front-end language.