Boomerangcare is a trusted, reliable Medical Transportation in New Jersey. They Provide Non-Emergency Medical Transportation which includes Wheelchair Transportation, Mobility Assistance, Ambulance/BLS, Group and individual transport on a one-time or recurring basis, transportation for children for after-school activities, events, and field trips.

Non Emergency medical transportation Services

If your new to Spring Data JPA, we highly recommend you check out this intro to <a id=0 href='https://www.stackchief.com/blog/Spring%20Data%20JPA'>Spring Data JPA</a> first...

@OneToMany Bidirectional Example (Best Approach)

    @GeneratedValue(strategy = GenerationType.AUTO)

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, orphanRemoval = true)

private Set<Book> books = new HashSet<>();

    @GeneratedValue(strategy= GenerationType.AUTO)

        if (!(o instanceof Book )) return false;

        return id != null && id.equals(((Book) o).getId());

This creates a one-to-many relationship between an author and book table. An author has many books.

Using both @OneToMany and @ManyToOne makes this a bidirectional relationship.

The mappedBy = "author" attribute tells us the book table is the owning side of the relationship.

The cascade = CascadeType.ALL tells Hibernate to propagate changes from any book to its related entities. For example, if we remove an author then all of its books will also be deleted from the database.

The orphanRemoval = true tells Hibernate to automatically remove orphaned entities. A book would become an orphan if it's removed from the author's list of books. This option tells Hibernate to automatically delete orphans.

The helper methods addBook() and removeBook() are useful in keeping the persisted context in sync. Strange things can happen when both sides of the bidirectional relationship aren't updated. The database can get out of sync with the context and unexpected things can happen. These methods make it easy to update both sides of the relationship...

The fetch = FetchType.LAZY tells Hibernate to lazily load books for a given author. This means when we retrieve an author from the database, Hibernate won't return the associated books for that author in the same call. A separate request is made to the database only when the application explicitly asks for author.getBooks().

It's important to @Override the equals() and hashCode() method since the Author entity relies on checking equality for it's helper methods...

insert into book (author_id, id) values (?, ?)

Author author = authorRepo.findById(Long.valueOf(1)).get();

select author0_.id as id1_0_0_ from author author0_ where author0_.id=?

select books0_.author_id as author_i2_1_0_, books0_.id as id1_1_0_, books0_.id as id1_1_1_, books0_.author_id as author_i2_1_1_ from book books0_ where books0_.author_id=?

@OneToMany bidirectional is the best approach because it results in the least SQL.  While you can implement the same relationship with other approaches (next examples), this is the recommended (most efficient) way to manage most one to many relationships with Spring Data JPA...

    @OneToMany(cascade = CascadeType.ALL)

insert into author_books (author_id, books_id) values (?, ?)

@OneToMany example including the best approach, bidirectional, unidirectional, generated SQL statements and comparisons.

One To Many Example | Spring Data JPA

Before jumping into @OneToOne examples, be sure to understand the basics of <a id=0 href='https://www.stackchief.com/blog/Spring%20Data%20JPA'>Spring Data JPA</a>.

1) @OneToOne Example Using Shared Primary Key (Best Approach)

    @OneToOne(mappedBy = "author", cascade = CascadeType.ALL)

This creates a one-to-one relationship between an author and book table. A book has one author and an author has one book.

Using the @OneToOne annotation, Hibernate knows to create a one-to-one relationship between the two entities.

The mappedBy="author" option tells Hibernate that the owning side of the relationship is the book table. This means the book table will hold the foreign key reference to the author table.

The cascade = CascadeType.ALL tells Hibernate to propagate changes to all associated entities. If you delete an instance of Author it will delete the associated Book entity automatically.

The @PrimaryKeyJoinColumn tells Hibernate that the primary key for the author table will be used as the foreign key in the owning book table.

The @MapsId tells Hibernate that the primary key on the author table will be used as the primary key for the book table. Since the primary key is being reused, we don't need a to specify @GenderatedValue on the book table.

This generates the following in the database...

When retrieving entities from the database, associations will be eagerly loaded by default:

Author author = authorRepo.findById(24) //returns both the author and its associated book in single DB call

By utilizing the primary key of the author as both the primary key and foreign key of the book table, you achieve the same result with fewer keys. This saves operating costs as primary/foreign keys are typically indexed and loaded into memory for efficient lookups. You're achieving the same result with fewer keys via a unidirectional relationship.

With this approach, the author table is the owning side of the relationship. This means the author table will have the foreign key book_id. For these reasons, the mappedBy = is moved to the Book entity definition.

Since the primary key is no longer being reused in both tables, the Book entity must now generate its own id values. For these reasons, the @GeneratedValue annotation exists on both entity classes.

Note: Unlike the last example, we now save the author entity to create the associations in the database. Whichever side owns the relationship must be saved to create entries in both tables.. Otherwise, you will run into issues with transient objects not being saved and exceptions being thrown.

Notice how the author table now has 2 columns.  This is because a foreign key is being used to create a bidirectional relationship between books and authors.

This example clearly demonstrates the advantage of the first approach as an extra book_id is needed to achieve the relationship.

                    { @JoinColumn(name = "author_id", referencedColumnName = "id") },

                    { @JoinColumn(name = "book_id", referencedColumnName = "id") })

One to One Example using Spring Data JPA and Hibernate including shared primary key, unidirectional, and bidirectional examples.

One To One Example | Spring Data JPA

This quick start guide will show you how to configure a Spring Data JPA project using Maven. If you are new to Spring Data JPA, we recommend checking out this <a href='https://www.stackchief.com/blog/Spring%20Data%20JPA'>Spring Data JPA intro</a> first.

1) Including Maven Dependencies in pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<artifactId>spring-data-jpa-examples</artifactId>

<description>Demo project for Spring Boot</description>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

<artifactId>mysql-connector-java</artifactId>

<artifactId>spring-boot-starter-test</artifactId>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

This includes all of the libraries you'll need to work with Spring Data JPA including:

spring-boot-starter-data-jpa: Includes libraries for <a href='https://www.stackchief.com/blog/Spring%20Data%20JPA%20vs%20Hibernate'>Hibernate</a>, the JPA specification, JDBC, and spring-data-jpa itself.

mysql-connector-java: This is required dependency for MySQL implementation. It's the MySQL connector library for Java.

spring-boot-starter-test: This includes libraries for testing Spring Boot applications.

To install the dependencies listed in the pom.xml simply run:

To package the application into an executable file run:

Entities are classes you define that represent tables in the MySQL database.  Let's create an authors entity and a books entity.  This will help with relationship examples (OneToMany, ManyToMany):

package com.example.springdatajpaexamples;

A quick start guide to using Spring Data JPA with Maven including join examples, one to many, find by embedded object, json columns and more.

Quick Start | Spring Data JPA

Java is both a compiled and interpreted language. While the javac tool takes the source code .java files you writes and compiles them to bytecode .class files, the JVM interprets this bytecode to produce machine code. This machine code is then fed to the CPU to ultimately process or run your program.

To maximize performance, Java utilizes a just-in-time (JIT) compiler to dynamically compile bytecode to machine code.  This JIT compiler is baked into the JVM and works automatically without any developer intervention.

While developers rarely need to concern themselves with the inner workings of this JIT, it's beneficial to understand what's happening under the hood.  This starts with understanding the difference between compiled vs interpreted languages..

Preface: Compiled vs Interpreted Languages

Languages like C and C++ are compiled languages.  These languages compile source code into an executable binary file that runs directly on the processor (CPU).

Compiled languages are good because they don't require any overhead during runtime.  Unlike an interpreted language, compiled code doesn't need to be evaluated at runtime.  This makes compiled languages generally faster than interpreted languages.

Compiled languages can be bad because they lack portability.  The compiled binary output is often specific to a certain architecture or platform.  The compiled output of your program may work on this machine but not that machine etc.

Compiled languages are also slower on startup and during testing.  This is because they need to be compiled first!

Languages like php, Python, and JavaScript are interpreted languages.  These languages rely on a separate program (the interpreter) to "interpret" the code during runtime.

Instead of compiling the source code upfront, interpreted languages read source code line by line, generating the binary instructions through the interpreter itself.  This makes it possible for interpreted languages to be "platform agnostic" meaning they can run on different platforms the same way.

Interpreted languages are good because they are portable.  You can download php for Mac, Windows, etc and your program will execute the same way.

Interpreted languages are bad because they take longer to execute code.  Unlike a compiled language, interpreters can't feed compiled code directly to a processor.  They have to "interpret" the source code line by line.

Interpreted languages make for faster startup times.  You don't have to wait for the compile step when your program starts.

The JIT compiler allows Java to be both a compiled and interpreted language.  It combines the performance advantage of a compiled language with the flexibility of an interpreted language.

When your Java program executes, the JVM interprets bytecode as part of code analysis and optimization.  It then uses this analysis to dynamically compile and store frequently reused methods to avoid interpreting the same bytecode over and over.

What does this JIT compiler look like?  Where does it live? How does it work?

The JIT compiler is part of the JVM that continuously runs to optimize performance.  While the JVM interprets bytecode, the JIT analyses execution and dynamically compiles frequently executed bytecode to machine code.  This prevents the JVM from having to interpret the same bytecode over and over.

The JIT compiler is not some separate application you download and run alongside your program.  It is simply a description of functionality that exists within the JVM.

The source code you write (.java) is compiled by javac to bytecode. When your program executes, the JVM starts interpreting this bytecode.

The interpreter translates the bytecode into machine code and feeds it to the CPU for processing.  While this happens, the JIT profiles and analyses the code execution.  It tracks the most frequently called methods and dynamically compiles these to machine code at runtime.

This dynamic process prevents the interpreter from having to "interpret" the same methods over and over.  Instead of having to translate bytecode to machine code, the interpreter can instead leverage cached machine code instructions from memory.

This is what makes Java both a compiled and interpreted language.  While the JVM initially interprets code, the JIT compiler works to selectively compile frequently executed code "just in time".

This gives Java the advantage of interpreted languages (faster startup times, more portability) and compiled languages (faster execution, optimized performance).

Client Side, Server Side, and Tiered Compilers

Before Java 8, you could specify either client or server JIT compilers.  While client compilers were better suited for apps having fewer resources available, server compilers worked better for long running apps.

A client side application may be more sensitive to startup time and have fewer resources available for code optimizations and JIT overhead.   A server side application may be long running and more appropriate for heavier optimizations and longer compile times.

The key difference between the two is the level of optimization and profiling. While profiling allows the JIT to better optimize the machine code it sends to the processor, it comes with a performance cost. Client side compilers minimize profiling to reduce overhead and startup time whereas server side compilers rely more heavily on profiling and optimizations.

Beginning with Java 8, the JVM takes a "tiered approach" where both client side and server side techniques are used.  During execution, the JVM initially interprets the bytecode.  It tracks frequently used methods and optimizes code based on the client side (C1) approach.  The JIT continuously analyzes execution and migrates to more of a server side (C2) approach for additional optimizations.

While modern Java installs utilize the tiered approach of combining C1 and C2 compilers, the C2 compiler is dated and hard to maintain.  For these reasons, the Graal JIT compiler was developed as part of a larger GraalVm project.

The Graal JIT compiler is written in Java, giving it the advantage of IDE integration, exception handling, and integration with profilers and debuggers.

The Graal JIT compiler also allows ahead of time (AOT) compiling where execution code is compiled upfront.  This reduces startup time experienced with the conventional JIT compiler.

There is a popular misconception that you can "download" a JIT compiler for Java.  While older versions allowed you to install a JIT as a plugin, all standard Java installations include the JIT compiler as part of the JVM.

As the JIT dynamically compiles code to machine language, it also performs optimizations on your source code to maximize performance.  Following are some examples of these optimizations:

The JIT compiler will optimize the original myMethod() through several steps...

Notice how the get() method is replaced with directly accessing the value. This eliminates method invocations and improves efficiency.

By setting z = a, the compiler reduces the latencies of accessing b.value to improve performance.

Notice how this optimization removes unnecessary variables. Since z ultimately just equals a the JIT compiler removes it altogether.

Since a = a is redundant, the JIT compiler simply removes this "dead code" during optimization.

Apart from these steps, JIT compiler also includes other optimizations like:

Let's say you have a basic null check like:

If JIT notices myVar is never called with null then it will remove this code altogether.

Let's say you have an if..else branch like this:

If the JIT compiler notices that x < y more often than not, it will reverse the branch...

If you have a nested loop, the JIT compiler will unroll it to minimize assembly jumps..

The JIT Compiler in Java including what is the JIT compiler, how the JIT compiler works, JIT compiler optimizations and more.

The JIT Compiler in Java

When starting your Java application, you may encounter this error:

Error: Could not find or load main class MyClass

Caused by: java.lang.ClassNotFoundException: MyClass

This error is very common when creating new Java based projects.  Whether you're using Gradle or Maven, Spring Boot or Kafka, chances are you've encountered this error before.

Sometimes the error will occur unexpectedly.  Sometimes the error is specific to your IDE.

Regardless, fixing the error is easy and it starts with understanding the cause:

What Causes the "Could Not Find or Load Main Class" Error?

This error is thrown whenever Java can't find or load the main class of your application.

Let's say you define a class like this:  

  public static void main(String[] args) {

    System.out.println("My class is working!");

When running this simple class, you could get the "could not find or load main class" error for several reasons...

Most IDEs let you configure the starting point for your application.  For example, in IntelliJ you can edit configuration to select a main class for running the project.

If you're running your application through an IDE, make sure that it is configured properly to look for the main class in the right place.

Remember that class names must be unique in Java.  Furthermore, they are case sensitive...

Let's say you are running your program from the CLI using the java tool..

This will result in the "Could not find or load main class" error because class names are case sensitive.

When running from the command line, many developers accidentally append an extension like:

The correct way is to run without any extension:

Let's say your class is part of a package like this:

If you don't run your class with the fully qualified name AND from the right directory, you will get the "Could not find or load main class" error...

The class path is where the JVM looks for classes to load into your program.  Sometimes developers provide a specified path like this:

While the optional -cp argument allows you to specify your own class path, you can easily get the "Could not find or load main class" error if this is incorrect...

How to fix the "Could Not Find or Load Main Class" Error

1. Make sure your IDE is configured properly

Make sure that your IDE has the correct configuration for finding the main class/entry point of your application.

2. Make sure your class name is correct

If you are running your program from the CLI, make sure that you are specifying the right class name without extensions...

3. Make sure you are running your application from the right directory

Make sure you are running your application from the right folder.  If your class is part of a package then you must run it from the parent directory....

4. Make sure your class path is correct

Make sure your class path is correct. By default, the class path is the current working directory ".". If you override this with the -cp argument then make sure it's accurate!

Understanding the Java Error "Could Not Find or Load Main Class"

While this error is self explanatory and easy to fix, it's worth understanding how Class Loaders work behind the scenes.  This gives you a better understanding of why the "Could Not Find or Load Main Class" error happens...

Classes are loaded dynamically.  This means classes are loaded into memory only when they are needed.  

Unlike C++, Java is a dynamically compiled language.  This means the language is compiled to machine code while the program is running.

Of course, some classes must be loaded initially when your program starts.  The JRE utilizes a native class loader to load the main entry point of your application.  From here, class loaders are used to dynamically load (lazy load) classes as they are needed by the application.

Java utilizes a delegation mechanism for loading classes at runtime.  There are 3 built-in class loaders used by the JRE at runtime:

1. Bootstrap class loader: This loads the standard runtime classes found in rt.jar

2. Extensions: This loads any extension classes used by the JRE

3. System: This loads classes defined by the application and found on the class path

Each class loader first checks a cache to see if the requested class has already been loaded into memory.   If nothing is found in the cache, it delegates the finding of the class to the parent class loader.

If the system class loader can't find the class, it delegates to the extension class loader.  

If the extension class loader can't find the class, it delegates to the bootstrap class loader.

If the bootstrap class loader can't find the class, it tells the extension class loader to find it

If the extension class loader can't find the class, it tells the system class loader to find it

If the system class loader can't find it, it throws an ClassNotFound exception

This mechanism works to ensure uniqueness, visibility and delegation are applied to the class loading mechanism in Java.

Uniqueness explains the reason why no two classes can have the same name. By keeping class names unique, class loaders can easily find the single representation of a defined class.

Visibility explains the child-parent relationship between class loaders. While children can view parent classes, parents can't view child classes. This ensures an isolation level needed to create the hierarchy between class loaders.

Delegation explains how the class loaders work together to recursively retrieve a unique class. By delegating to parent classes, class loaders ensure only one representation of a defined class exists.

1) Class loader searches cache for loaded classes

2) If cache has the class, it is returned.  Otherwise, the class loader delegates to parent class to retrieve the class

3) Parent class loaders ultimately delegate to the bootstrap class loader.  If the class isn't found, the bootstrap loader returns responsibility to child loader.

4) Either the system loader finds and loads the class, or a ClassNotFound exception is thrown.

You can create your own class loaders by extending the ClassLoader class:

public class CustomClassLoader extends ClassLoader { ...

Most developers don't need to worry about creating custom class loaders.  There are times where it makes sense however. Sometimes custom class loaders are used to implementing class versioning.  Other custom class loaders allow you to create classes dynamically or switch implementations etc.

The "Could not find or load main class" error is common and easy to fix.  Its cause usually has to do with specifying the wrong class name, extension, or class path.  

This error can be easily fixed by checking IDE configurations, class path variables, class names, and making sure you're running the application from the right directory.

The JRE utilizes a class loading mechanism to dynamically load classes into memory.  This mechanism relies on a recursive process where class loaders delegate retrieval to parent loaders if they can't find the class already loaded in memory.

You can create your own custom class loaders for dynamic class creation and versioning.

The "Could Not Find or Load Main Class" error including solutions, fixes, when are classes loaded in Java, the class loading mechanism in Java, and Java class loading order.

Could Not Find or Load Main Class Error | Java

Understanding Java garbage collection begins with the heap and the stack. If you aren't familiar with <a id=1 href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>Java Heap vs Stack</a> be sure to read <a id=1 href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>this</a> first.

Garbage collection is the automatic process for handling memory management.  Memory management is the dynamic process of allocating/deallocating memory to/from your application.

Memory management is not unique to Java.  Every programming language must provide a means of requesting memory from the underlying OS and releasing memory when it's no longer needed. This allows programs to run without consuming too much memory or causing applications to crash.

Some languages like C and C++ require a manual process for allocating/deallocating memory.  Programmers must write constructor and destructor functions to allocate memory when it's needed and release it when objects are no longer being referenced by the application.

While this manual process gives developers more control over memory management, it's ultimately more tedious, repetitive, and vulnerable to memory leaks and other errors.  For these reasons, programming languages like Java implement an automatic garbage collection mechanism for managing memory.  This mechanism operates independently from the application code allowing developers to write code without worrying about memory management.

Why is garbage collection important in Java?

Garbage collection (GC) is important because it automatically handles memory management in Java.  This makes Java memory-efficient without the developer's intervention. As a developer, you can write Java code without worrying about memory allocation.  GC handles all of this for you.

While GC "magically" handles memory management for the developer, it's still important to understand what's going on under the hood. If you've ever experienced a OutOfMemory exception then you know GC won't save you every time. Furthermore, there are different implementations of GC and various configurations for optimizing this process based on the nature of your application.

Having a good grasp on the GC mechanism will help you write better code and avoid performance issues related to memory management.

Java applications run inside the JVM. The OS running your Java program allocates a configurable amount of <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>heap space</a> memory to the JVM for running your applications.

The above are two sample arguments for configuring min and max <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>heap space</a> for the JVM.

Since the JVM has a predetermined allotment of memory for running applications, it doesn't need to synchronize with the underlying OS for memory resources.  Instead, it can utilize this same memory space and free up unused memory without deleting or requesting more from the OS.  This is fundamental to what makes Java memory-efficient as a programming language.

Application execution: Java Heap vs Stack

When your application starts up, classes and methods are loaded into the <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>heap space</a>. As your program executes, objects are created and referenced in the <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>heap space</a> by the <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>stack</a>

While the <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>heap</a> represents a global space of memory that exists throughout the duration of your application, the <a href='https://www.stackchief.com/blog/Java%20Heap%20vs%20Stack'>stack</a> only exists during method or thread execution. Once a method finishes execution, the memory used is released from the stack via a relatively simple FIFO approach.

This simple approach is sufficient for automatically handling memory living in the stack (local variables and references to objects stored in the heap) but what about actual objects referenced in the heap?

Garbage collection in Java including understanding what is garbage collection, why garbage collection, how garbage collection works in Java, force garbage collection, monitoring garbage collection and interview questions.

Non Emergency medical transportation Services...

The JIT Compiler in Java

Could Not Find or Load Main Class Error | Java

Garbage Collection in Java

Java Heap vs Stack

JavaScript Observables in 5 Minutes

Spring Boot Kafka Consumer JSON Example