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

# What is Hibernate?
**Hibernate** is an open-source Java ORM persistence framework.

Hibernate can be used to simplify the mapping of SQL databases to Java Objects and includes its own query language (HQL), a Java API for writing queries, and the ability to specify mappings via annotations or XML.




# Starting out
To begin using Hibernate:
* Include the latest Hibernate jar using your preferred build framework.
* Add your entity classes and mappings.
* Define the Hibernate configuration.
* Create the HQL queries necessary to implement your application.

For example, using Gradle, add the following to your dependencies:
``` java
compile 'org.hibernate:hibernate-core:5.2.12.Final'
compile 'org.hibernate:hibernate-hikaricp:5.2.12.Final'
```

# Mappings
Each entity class should be public and have a public no-args constructor. Entities can be configured via an XML file in the same package and ending in `.hbm.XML` or via annotations within the entity. For simplicity, we will only cover the annotations.

## Table annotation
For this example, imagine we need to store a `Book` entity class in a table named `BOOKS`:
``` java
import javax.persistence.*;
@Entity
@Table( name = "BOOKS" )
public class Book {
...
}
```
The `@Table` annotation can be used to specify a table name but is not required. Otherwise, the table name of `BOOKS` will be used.

Without any additional annotations, all attributes of the `Book` class will be mapped directly to persistent columns of the same name with default types based on the Java types. However, many other annotations are available to customize the mapping. The following listing defines the primary key for the table:


``` java
@Id
@GeneratedValue(generator = "inc")
@GenericGenerator(name="inc", strategy = "increment")
public Long getId() {
     return id;
}
```
The `@Id` marks this property as the entity’s identifier, which acts as the primary key of the table. The next two annotations specify the automatic generation of values for the property using the increment strategy . This is the simplest way of providing a unique identifier for a database, and it is useful for most applications.

## Column annotation
``` java
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "PUBLISH_DATE")
public Date getDate() {
    return date;
}
```
The `@Column` annotation allows us to specify the column’s name differently from the property’s name, among other things. It also has optional elements including `nullable`, `length` (for `varchar` and other
types), `unique`, `insertable`, and `updatable`.

For one-to-many relationships, use a `@OneToMany` annotation on a List or Set property.

> Property annotations such as `@Id` and `@Column` may be used on the field instead of the getter method or properties.

# HQL
**HQL** is like an enhanced SQL that allows us to use names from the Hibernate mappings within our queries rather than the SQL field names.

Given the Book example, you might construct a query like the following:

``` java
String hql = "from Book where date > :start"; //1
Query qry = sessionFactory.getCurrentSession().createQuery(hql); //2
qry.setParameter("start", new Date()); //3
return qry.list(); //4
```
1. Define the HQL query. Without a `select` statement, a list of `Book` entities will be returned.
2. Use a previously configured SessionFactory to get the current session and create a Query.
3. Set any parameters required by the query.
4. Call the `list()` method to get the results of the query. In this case, a List of `Book` entities with a date greater than the given date (today).

Almost everything we can do in SQL, group by, order by, limit, inner joins, and outer joins can be done in HQL with the added benefit of using our Java-based entity names and the ability to dereference one-to-many or many-to-one relationships without using a join. For example, imagine if the `Book` entity has a List called `authors` mapped using the `@OneToMany` relationship. Then the following query could be written to get all books (with an author) with a name matching
the `name` parameter:

``` java
"from Book b where b.authors.name like: name"
```
# Configuration
The configuration for Hibernate should include the DataSource to use (or multi-tenant connection provider if we have multiple tenants), the list of XML mapping files or what classes to scan for annotations, and cache configurations.

Configuration can be done in the `hibernate.cfg.xml` or other ways. Frameworks such as Grails have some built-in support for Hibernate and allow us to configure it differently.

# Connection pools
For most applications, we should use a database connection pool to improve performance. A connection pool handles opening and closing connections and keeps some number of connections open at any given time based on configuration and the connection needs of our application.

Some commonly used connection pools for Java follow:
* HikariCP
* C3P0
* Apache Commons DBCP Component

Of these, Hikari seems to have the best performance.

Learn about Hibernate, an object-relational mapping framework in Java.

Hibernate

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

Hibernate

What is Hibernate?

Starting out

Mappings

Table annotation