Full Stack Kotlin Development
- 6 hours on-demand video
- 1 downloadable resource
- Full lifetime access
- Access on mobile and TV
- Certificate of Completion
Get your team access to 4,000+ top Udemy courses anytime, anywhere.Try Udemy for Business
- 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
• Kotlin dynamic keyword and external class definitions
• Communicate with Kotlin application backend with XHR
Creating a single frontend artifact and increase the velocity of Kotlin frontend development.
• Configure Kotlin frontend plugin for the application
• Run the frontend with Webpack and make use of hot reloading
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
- Back-end and front-end developers are a different breed
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.