Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

There are many ways to render a response.

# Groovy text
If you prefer to use a plain old text document with embedded groovy (much like a GString), you  can
use the `TextTemplateModule`:

```
import ratpack.groovy.template.TextTemplateModule;
import static ratpack.groovy.Groovy.groovyTemplate;
import static ratpack.groovy.Groovy.ratpack;
ratpack {
    bindings {
        module TextTemplateModule
    }
    handlers {
        get(":key") {
            def key = pathTokens.key
            render groovyTemplate("index.html", title: "$key")
        }
    }
}
```
Then create a file named `index.html` in the `src/main/resources/templates` directory with the following content:
```html
<html><h2>${model.title}</h2></html>
```
It supplies a `model` Map to your template, which contains all of the parameters you supply.

## Handlebars and thymeleaf
Ratpack also supports handlebars and thymeleaf templates. Since these are static resources, we
should put these templates in the `src/main/resource` directory.

We will first need to include the appropriate ratpack project in your Gradle build file:

```
runtime 'io.ratpack:ratpack-handlebars:1.1.1'
runtime 'io.ratpack:ratpack-thymeleaf:1.1.1'
```
To use Handlebars, include the `HandlebarsModule`, and render handlebar templates as follows:

```
import ratpack.handlebars.HandlebarsModule
import static ratpack.handlebars.Template.handlebarsTemplate
import static ratpack.groovy.Groovy.ratpack
ratpack {
    bindings {
        module HandlebarsModule
    }
    handlers {
        get("foo") {
            render handlebarsTemplate('myTemplate.html', title: 'Handlebars')
        }
    }
}
```
Create a file named `myTemplate.html.hbs` in the `src/main/resources/handlebars` directory with handlebar content. For example:

``` html
<span>{{title}}</span>
```
Thymeleaf works in a similar way:

```
import ratpack.thymeleaf.ThymeleafModule
import static ratpack.thymeleaf.Template.thymeleafTemplate
import static ratpack.groovy.Groovy.ratpack
ratpack {
    bindings {
        module ThymeleafModule
    }
    handlers {
        get("foo") {
            render thymeleafTemplate('myTemplate', title: 'Thymeleaf')
        }
    }
}
```
The requested file should be named `myTemplate.html` and be located in the `src/main/resources/thymeleaf` directory of our project. Example content:

```html
<span th:text=\"${title}\"/>
```

## JSON
Integration with the Jackson JSON marshalling library provides the ability to work with JSON as part of ratpack-core.

The `ratpack.jackson.Jackson` class 
 provides most of the Jackson related functionality. For example,
to render json you can use `Jackson.json`:

```
import static ratpack.jackson.Jackson.json
ratpack {
    bindings {}
    handlers {
        get("user") {
            render json([user: 1])
        }
    }
}
```
The Jackson integration also includes a Parser for converting JSON request bodies into objects. The
`Jackson.jsonNode()` and `Jackson.fromJson(Class)` methods can be used to create parcelable objects
to be used with the `parse()` method.

For example, the following handler would parse a JSON string representing a Person object and
render the Person’s name:

```
post("personNames") {
   render( parse(fromJson(Person.class)).map {it.name} )
}
```
> `Context.parse` returns a Promise.

Learn about different ways to render a response.

Rendering and JSON

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Rendering and JSON

Groovy text