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

# Gradle properties
The `Gradle.properties` file allows us to specify Gradle properties and other properties available to our build script. We could also specify build-specific values that we don’t want to keep in our versioning system (such as nexus credentials). For example, we can specify JVM arguments, and if we want to use the Gradle daemon:

```
org.gradle.daemon=true
org.gradle.jvmargs=-Xms128m -Xmx1024m
deploymentPassword=123
```
This would tell Gradle to pass `-Xms128m -Xmx1024m` command-line arguments to Java. These arguments  start with a minimum of 128 megabytes of memory and maximum of 1024 megabytes for Java 8. It would also add `deployment` password as an available property in the build file.




# Multi-project builds
A multi-project build can include any number of sub-projects that are built together. Each sub-project
should be put in a directory under a single top directory where the name of each directory is the name
of the sub-project.

Separate builds in a multi-project build may depend on one another. You can express dependencies
on any number of subprojects using the following syntax:

```
dependencies {
   compile project(':subproject1')
   compile project(':subproject2')
}
```

The top-level `build.gradle` file of a multi-project should look something like the following:
```
allprojects {
      plugins {  
          id 'groovy'
      }
}
project(":subproject1") {
      dependencies {}
}
project(":subproject2") {
      dependencies {}
}
```
# File operations
Since Gradle evaluates tasks before actually executing them, we should generally not use `java.util.File` for defining files. Instead, Gradle provides several built-in methods and tasks. For example, use the `file` method for single files and the `files` method to define a collection of files.

```
outputDir = file("libs/x86")
```
There is also a `fileTree` method for recursively listing a directory of files. For example, we can depend on all files under the `lib` directory in the following way:
```
dependencies {
  compile fileTree('lib')
}
```
To copy files from one place to another, we should use the `Copy` task. Here’s a good example:

```
task copyImages(type: Copy) {
    from 'assets'
    into 'build/images'
    include '**/*.jpg'
    exclude '**/*test*'
}
```
The above task would copy all images that end with `.jpg` in the `assets` directory into the `build/images` directory, excluding any files containing the word “test.” Let’s see this below:

Properties

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

Properties

Gradle properties