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

# Configuring a task
Once you’ve added some plugins, configure some of the properties of a task for your purposes.

For example, specify a version of Gradle for the Gradle `wrapper` task:

```
task wrapper(type: Wrapper) {
     gradleVersion = '5.1'
}
```
The properties available depend on what task we are configuring.

# Extra configuration
To provide extra properties within your Gradle build file, use the `ext` method. We can define any
arbitrary values within the closure, and they will be available throughout your project.

We can also apply properties from other Gradle build files. For example:

``` java
ext {
    apply from: 'props/another.gradle'
    myVersion = '1.2.3'
}
```
The properties defined within this closure can be used in your tasks.

# Maven dependencies
Every Java project tends to rely on many open-source projects to be built. Gradle can use `mavenstyle` repositories, so we can easily include your dependencies using a simple DSL like in the following example:

``` java
plugins {
      id 'java'
}

sourceCompatibility = "11"

repositories {
     mavenLocal()
     mavenCentral()
}

dependencies {
    compile 'com.google.guava:guava:14.0.1'
    compile 'org.bitbucket.dollar:dollar:1.0-beta3'
    testCompile group: 'junit', name: 'junit', version: '4.+'
    testCompile "org.mockito:mockito-core:1.9.5"
}
```
This build script uses `sourceCompatibility` to define the Java source code version of 11 (which is used during compilation). Next, it tells Maven to use the local repository first (`mavenLocal`) then Maven Central.

In the `dependencies` block, this build script defines two `dependencies` for the compile scope and two for the `testCompile` scope. Jars in the `testCompile` scope are only used by tests and won’t be included in any final products.
Gradle can use a compact syntax of `groupId:artifactId:version`, so “com.google.guava:guava:14.0.1” becomes “groupId = com.google.guava, artifactId = guava, version = 14.0.1.”

The line for JUnit shows the more verbose style for defining dependencies. Also, “4.+” means using the highest version starting with “4.”


We can also specify our own Maven repository by calling maven with a closure supplying the appropriate parameters (at least a URL). For example, in the repositories section:

``` java
maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
maven { url = "$nexus/content/groups/public"
       credentials {
             username 'deployment'
             password deploymentPassword
       }
}
```
The second example demonstrates using a secured maven repository. It also demonstrates using the variables `nexus` and `deploymentPassword`, which could (probably should) be stored in a
`gradle.properties` file.

Configuration

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

Configuration

Configuring a task

Extra configuration