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

# Introduction
There is a simple way to create a new configuration file (`pom.xml`) and project folders using the `archetype:generate` command:
```Java
mvn archetype:generate
```
This will list all of the different types of projects we can create. Pick a number representing the type of project you want.  Then answer some questions regarding the name of your project. After that process, run the following command to build the project:
```java
mvn package
```
If we want to use any additional third party libraries, we will have to edit the POM to include each dependency. Fortunately, most IDEs make it easy to add dependencies to the POM.

# Lifecycle
Maven uses a declarative style, while Antuses a more imperative approach. This means that instead of listing the steps to take, we describe what should happen during certain phases of the build. The main phases in Maven are as follows:

* `validate`: Ensure that the project is correct and all necessary information is available.
* `compile`: Compile the source code of the project.
* `test`: Test the compiled source code using a suitable unit testing framework.
* `package`: Take the compiled code and package in its distributable format, such as a JAR.
* `integration-test`: Process and deploy the package, if necessary, into an environment where integration tests can be run.
* `verify`: Run any checks to verify the package is valid and meets quality criteria.
* `install`: Install the package into the local repository for use as a dependency in other projects locally.
* `deploy`: This is done in an integration or release environment and copies the final package to the remote repository for sharing with other developers and projects.

# Dependencies
We can add dependencies by specifying their coordinates, which are `groupId:artifactId:version`. For
example:
```Java
<dependencies>
    <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-engine</artifactId>
         <version>${junit.jupiter.version}</version>
         <scope>test</scope>
    </dependency>
</dependencies>
```
By default, Maven will look for the corresponding JAR file in Maven Central, which is a long running, highly available server that any open source project can publish to.

>The scope can be “test” or “compile.” But it is “compile” by default. The “test” scope means this JAR is only available while compiling and running tests.

# Properties
We can define properties in the “properties” block. For example:
```
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <main.class>com.example.test.HelloWorld</main.class>
    <java.version>8</java.version>
    <junit.jupiter.version>5.4.2</junit.jupiter.version>
</properties>
```
This would set `java.version` to 8 and `junit.jupiter.version` to `5.4.2`. The latter is used in the previous section to define our dependency.

# Executing code
However, sometimes we just need more control over our build. In Maven, we can execute groovy code, Ant-build files, Scala code, and we can even write our own plugins in groovy.

For example, we can put groovy code in our POM file in the following way:


```Java
<plugin>
  <groupId>org.codehaus.groovy.maven</groupId>
  <artifactId>gmaven-plugin</artifactId>
  <executions>
    <execution>
       <id>groovy-magic</id>
       <phase>prepare-package</phase>
       <goals>
          <goal>execute</goal>
       </goals>
       <configuration>
          <source>
            def depFile = new File(project.build.outputDirectory, 'deps.txt')

            project.dependencies.each() {
                depFile.write("${it.groupId}:${it.artifactId}:${it.version}")
            }

            ant.copy(todir: project.build.outputDirectory ) {
                fileset(dir: project.build.sourceDirectory)
            }
          </source>
       </configuration>
    </execution>
  </executions>
</plugin>
```
The above code will write out every dependency of the project into the file `deps.txt`. Then it will copy all of the source files into the `project.build.outputDirectory` (usually target/classes).



Learn how to start a new project with Maven.

Starting a New Project

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

Starting a New Project

Introduction