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

# Ratpack layout
* `build.gradle`: The Gradle build file
* `src - main/java`: Where you put general Java classes.
  * `main/groovy`: Where you put general Groovy classes.
  * `main/resources`: Where you put static resources, such as Handlebars templates.
  * `test/java`: Where to put your Java based tests.
  * `test/groovy`: Where to put your spock Specs and other groovy tests.
  * `ratpack`: Contains 
  * `ratpack.properties`.
  * `ratpack/public`: Any public files like HTML, JavaScript, and CSS
  * `ratpack/templates`: Holds your Groovy-Markup templates (if you have any).


# Handlers
Handlers are the basic building block for Ratpack. They form something like a pipeline or “[Chain
of Resposiblity](http://www.oodesign.com/chain-of-responsibility-pattern.html).”  Multiple handlers can be called per request, but one must return a response. If none of your handlers are matched, a default handler returns a `404` status code.

```
File base = new File("/opt/myapp");
RatpackServer.start(server - > server
    .serverConfig(ServerConfig.builder().baseDir(base).build())
    .handlers(chain - > chain
        .all(ctx - > {
            ctx.getResponse().getHeaders().add("x-custom", "X");
            ctx.next();
        })
        .get("foo", ctx - > {
            ctx.render("foo handler");
        })
        .files(ctx - > ctx.dir("public"))
        .get(":key", ctx - > {
            String key = ctx.getPathTokens().get("key");
            ctx.render("{\"key\": \"" + key + "\"}");
        })
    )
);
```
1. Firstly, the base directory must be set using the ServerConfig before files can be served.
2. Secondly, we define the handlers.

The first handler `all()` is used for every HTTP request and adds a custom header, `x-custom`. It then
calls `ctx.next()` so the next matching handler gets called. The next handler that matches a given
HTTP request will be used to fulfill the request with a response.

The `files` handler is used to specify what files should be served. In the above example, we specify that all files in the `public` directory should be server;  this is relative to the baseDir.

The `pathTokens` map contains all parameters passed in the URL as specified in the matching path pattern (as in `:key`) by prefixing the colon (`:`) to a variable name you specify. In the above example, we simply return JSON with the key given in the URL.

You can define a handler using a method corresponding to any one of the HTTP methods:
* `get`
* `post`
* `put`
* `delete`
* `patch`
* `options`

To accept multiple methods on the same path, you should use the path handler and byMethod with
each method handler inside it. For example:
```
chain.path("foo", c - >
c.byMethod(spec - > {
    spec.post(ctx - > ctx.render("post foo"))
    .put(ctx - > ctx.render("put foo"))
    .delete(ctx - > ctx.render("delete foo"));
})
});
```

Layout and Handlers

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

Layout and Handlers