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

**Grails** is a web-framework for Groovy that follows the example of Ruby on Rails to be an opinionated web framework with a command-line tool that gets things done really fast. Grails uses convention over configuration to reduce configuration overhead.

Grails lives firmly in the Java ecosystem and is built on top of technologies like Spring and Hibernate. Grails also includes an Object-Relational-Mapping (ORM) framework called GORM and has a large collection of plugins.



Different versions of Grails can be very different, so care needs to be taken when upgrading your Grails application especially with major versions (2.4 to 3.0 for example).


# Quick overview of Grails

After installing Grails, you can create an app by running the following on the command-line:


```
$ grails create-app
```
Then, you can run commands like `create-domain-class` and `generate-all` to create your application as you go. Run `grails help` to see the full list of commands available.

Grails applications have a very specific project structure. The following is a simple break-down of most of that structure:


* **grails-app**: The Grails-specific folder
   * Conf - Configuration, such as the DataSource script and Bootstrap class
   * Controllers - Controllers with methods for index/create/edit/delete or anything else.
   * Domain - Domain model or classes representing your persistent data.
   * i18n - Message bundles
   * Jobs - Any scheduled jobs you might have should go here.
   * services - Back-end services where your back-end or “business” logic goes.
   * taglib - You can very easily define your own tags for use in your GSP files.
   * Views - Views of MVC are typically GSP files (HTML based).

* **src**: Any utilities or common code that doesn’t fit anywhere else.
   * Java - Java code
   * Groovy - Groovy code

* **Web-app** 
   * CSS - CSS style-sheets
   * Images - Images used by your web-application.
   * – js - Your JavaScript files.
   * WEB-INF - Spring’s `applicationContext.xml` goes here.

To create a new domain (model) class, run the following:
```
$ grails create-domain-class
```
It’s a good idea to include a package for your domain-classes, like `example.Post`.

A domain class in Grails also defines its mapping to the database. For example, here’s a domain class representing a blog post (assuming User and Comment were already created):

```
class Post {
    String text
    int rating
    Date created = new Date()
    User createdBy

    static hasMany = [comments: Comment]

    static constraints = {
        text(size:10..5000)
    }
}
```
The static `hasMany` field is a map, which represents one-to-many relationships in your database. Grails
uses Hibernate in the background to create tables for all of your domain classes and relationships.
Every table gets an `id` field for the primary key by default.

To have Grails automatically create your controller and views, run:

```
$ grails generate-all
```

When you want to test your app, you simply run:

```
$ grails run-app
```

When you’re ready to deploy to an application container (for example, Tomcat), you can create a `war` file by typing:
```
$ grails war
```

# Plugins
The Grails ecosystem now includes over one thousand plugins. To list all of the plugins, simply
execute:
```
$ grails list-plugins
```
When you’ve picked out a plugin you want to use, execute the following with the plugin name and version:
```
$ grails install-plugin [NAME] [VERSION]
```
This will add the plugin to your project. If you decide to uninstall it, simply use the `uninstall-plugin` command:
```
$ grails uninstall-plugin [NAME] [VERSION]
```


Introduction

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

Introduction

What is Grails?