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)

    @GeneratedValue(strategy = GenerationType.AUTO)

    @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 can happen for several reasons.  Not to be mean but the error clearly states the obvious here.  The problem is most Java developers don't learn about the class loading mechanism..

This class loading mechanism is "automagically" used by the JRE to identify unique classes and load them into memory.

The JRE utilizes a native operation to load bootstrapped classes. It then uses ClassLoader to locate and cache classes as they are dynamically used by the application.

So you probably aren't naming your class right or using the wrong extension, because Java just plain and simple can't find the class...

I am getting following error using IntellJ IDE...

Error: Could not find or load main class AddressCalc

Caused by: java.lang.NoClassDefFoundError: AddressCalc (wrong name: AddressCal)

Java could not find or load main class?

GC is an automatic mechanism that will collect unused objects and free up the memory space used for these objects.

GC is done automatically.  There is nothing you do as a developer to trigger this process

How does garbage collection work?

thanks for the great explanation on ngOnChanges.  really appreciate the ngOnChanges example...why can't the official documentation explain this as clearly???

Another question I have is how these lifecycle hooks (in general) compare to React and other frameworks.  From what I've heard, ReactJs is still king in terms of their diffing algo and performance.  

i think the way Angular handles change events is much simpler than ReactJS.  While these ngonchange examples may seem a bit overboard for JavaScript, it's still easier to understand these life cycle hooks than functional components in React (in my opinion).

Does anyone know what is more performant when it comes to things like React hooks (useEffect, useState) etc and things like ngOnChanges???

Steve Jennings

People often get confused when they see ngOnChanges fire before ngOnInit. At a high level you would assume ngOnInit is the first thing called when a component is rendered.

This post does a good job of emphasizing the fact that ngOnChanges is linked to children components and their bound @Input properties.  When you initialize a child component from a parent, you are setting the component's @Input properties as part of the component's initialization....

A child component's @Input properties are updated even before the component is initialized...

Alexander Joseph

hoopmiester

ngOnChanges example for Angular including latest version example with explanation

ngOnChanges Example | Angular

What is a good salary for a software engineer

What is a good salary for a software engineer?

this took longer than 5 minutes for me to understand but wow ...great explanation.

The Promise is still relevant and great for async operations where you are only concerned with the result of one async operation.  While the observable handles this well with Angular, it's still perfectly reasonable to use the Promise library for http requests, etc.

stackchief

Quickly understand JavaScript observables.  Implement the Observable class from scratch and understand what makes observables different from promises.

JavaScript Observables in 5 Minutes

So the Observable requires libraries and isn't native to JS?

The poll() method basically checks to make sure a single thread is accessing the consumer and then enters a do...while loop where the while condition is the provided time argument not being exceeded.

Brenda Becker

One To One Example | Spring Data JPA

This can happen for several reasons. Not to be mean but the error clearly states the obvious here. The problem is most Java developers don't learn about the class loading mechanism..

GC is an automatic mechanism that will collect unused objects and free up the memory space used for these objects.

thanks for the great explanation on ngOnChanges. really appreciate the ngOnChanges example...why can't the official documentation explain this as clearly???

What is a good salary for a software engineer?

this took longer than 5 minutes for me to understand but wow ...great explanation.

So the Observable requires libraries and isn't native to JS?

The <span class='code-bite'>poll()</span> method basically checks to make sure a single thread is accessing the consumer and then enters a <span class='code-bite'>do...while</span> loop where the <span class='code-bite'>while</span> condition is the provided time argument not being exceeded.