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

When should you use @OneToOne with @JoinTable in Spring Data JPA?

How does a @OneToOne relationship work in Spring Data JPA?

What is the purpose of CascadeType in Spring Data JPA / Hibernate?

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

If you're new to Kafka, be sure to check out <a id=0 href='https://www.stackchief.com/blog/Kafka%20Architecture%20Explained'>Kafka architecture explained</a> first. If your'e new to Spring Boot Kafka consumers, be sure to check out this <a id=0 href='https://www.stackchief.com/blog/Spring%20Boot%20Kafka%20Consumer'>Spring Boot Kafka consumer example</a> first...

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

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

<groupId>org.springframework.kafka</groupId>

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

<artifactId>spring-kafka-test</artifactId>

The above dependencies include everything you need to run Spring Kafka and test the example.

spring.kafka.bootstrap-servers=localhost:9092

These are the only Kafka configuration properties we define in application.properties. While we've only specified the consumer group and broker list, you can optionally configure more properties here if you so choose...

    public void setFirstName(String firstName) {

    public void setLastName(String lastName) {

This sets up our basic User model. We need this to tell our JsonDeserializer how to deserialize the input.

import org.apache.kafka.clients.consumer.ConsumerConfig;

import org.apache.kafka.common.serialization.StringDeserializer;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.kafka.annotation.EnableKafka;

import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;

import org.springframework.kafka.config.KafkaListenerContainerFactory;

import org.springframework.kafka.core.ConsumerFactory;

import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

import org.springframework.kafka.support.serializer.JsonDeserializer;

    @Value("${spring.kafka.consumer.group-id}")

    @Value("${spring.kafka.bootstrap-servers}")

public ConsumerFactory<String, User> consumerFactory() {

Map<String, Object> props = new HashMap<>();

        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, brokers);

        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);

return new DefaultKafkaConsumerFactory<>(props, new StringDeserializer(), new JsonDeserializer<>(User.class));

KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, User>>

ConcurrentKafkaListenerContainerFactory<String, User> factory =

new ConcurrentKafkaListenerContainerFactory<>();

        factory.setConsumerFactory(consumerFactory());

This is our main configuration for the Kafka client. Notice the use of the @EnableKafka to register configuration of our ConsumerFactory and ConcurrentKafkaListenerContainerFactory.

If you followed the <a id=71 href='https://www.stackchief.com/blog/Spring%20Boot%20Kafka%20Consumer'>previous example</a>, you'll notice we didn't include any of this configuration. We include these configurations in this example because we have to configure our JsonDeserializer.

By default, Kafka uses the StringDeserializer when consuming messages. Since we are consuming JSON, we must explicitly specify the Deserializer class to use for both the key and value via return new DefaultKafkaConsumerFactory<>(props, new StringDeserializer(), new JsonDeserializer<>(User.class)).

You'll also notice a reference to User. This is our model representing the object we want to read in from Kafka. Notice how we specify the User type both in defining the ConsumerFactory and the ConcurrentMessageListenerContainer.

import org.springframework.kafka.annotation.KafkaListener;

import org.springframework.stereotype.Component;

    public void processMessage(User user) {

        System.out.println("Message received by consumer 1: " + user.toString());

Spring Boot Kafka Consumer JSON example including Deserializer configuration etc.

Spring Boot Kafka Consumer JSON Example

1) What's an easy way to create a new topic with Spring Boot?

You can create a new topic via Spring Boot configuration by defining a NewTopic @Bean in the application context:

2) Is a KafkaAdmin bean automatically registered for you when using Spring Boot?

3) What happens when a broker is not available when starting the Spring Boot app?

The default behavior is the Spring context continues to load. You can optionally consider this behavior fatal by configuring the fatalIfBrokerNotAvailable property on the admin.

4) How is the KafkaTemplate class used in Spring Boot?

The KafkaTemplate class wraps a Kafka producer and makes it easy to send data to a topic using Spring Boot...

The message listener is an interface for handling incoming messages. There are 8 supported interfaces for message listeners. The MessageListener is called for each record returned by the underlying consumer poll() method.

6) What's the difference between KafkaMessageListenerContainer and ConcurrentMessageListenerContainer?

A KafkaMessageListenerContainer receives messages for all topics and partitions on a single thread. A ConcurrentMessageListenerContainer is a collection of KafkaMessageListenerContainer instances. It distributes message consumption across multiple threads.

7) What is the @KafkaListener annotation?

The @KafkaListener annotation can be applied to Java classes, methods, and method annotations. @KafkaListener is most commonly applied to methods, registering Kafka listener containers for those methods...

public void processMessage(String content){

    System.out.println("Message received: " + content);

In the above example, the processMessage() method is annotated with @KafkaListener. This method will be invoked when messages are read from the test topic.

Spring Boot Kafka Interview Questions, including how Spring Boot Kafka works, what different annotations do, etc

Spring Boot Kafka Interview Questions

If you're brand new to Kafka, be sure to check out this <a id=0 href='https://www.stackchief.com/blog/Kafka%20Architecture%20Explained'>intro to Kafka architecture</a> first.

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

<groupId>org.springframework.kafka</groupId>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

<artifactId>spring-kafka-test</artifactId>

The pom.xml defines the dependencies we need for our Maven build. Notice how we include the dependencies needed for Spring Boot along with those needed for running and testing Kafka.

Note that the jackson-databind dependency is included to account for bugs in older versions of the Spring Kafka library. You may not need to include this depending on which version of Kafka you're using..

	public static void main(String[] args) {

		SpringApplication.run(DemoApplication.class, args);

The DemoApplication.java class runs our Spring Boot application.

Spring Boot automatically configures Kafka via @SpringBootApplication. With this annotation, Spring provides/configures a KafkaAutoConfiguration class for you.

    public void processMessage(String content){

        System.out.println("Message received: " + content);

The Consumer.java class is what actually listens for messages. Notice how we specify the topics to listen to within the @KafkaListener annotation.

By simply using the annotations provided by the Spring Boot Kafka library, we are able to easily set up a consumer for a given topic.

Thanks to auto-configuration, you only need to define a few things in application.properties to configure the consumer. Notice how our app is configured to use Kafka locally.

This example is configured to consume from a local Kafka topic.  You'll need to have Kafka installed and running locally to see messages being consumed from the Spring Boot app.

To start Kafka locally, you need to start both the Zookeeper and Kafka servers locally...

./zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

This will start the zookeeper server with the default configurations.  Please note the path to your local Kafka install may vary.

./kafka-server-start /usr/local/etc/kafka/server.properties 

This will start the Kafka server with the default configurations.  Please note the path to your local Kafka install may vary.

To test the application consumer, you'll need to produce some messages for the test topic.  To start a Kafka console producer:

./kafka-console-producer --bootstrap-server=localhost:9092 --topic test

This starts a Kafka producer for the test topic. Notice how both the bootstrap-server and topic arguments match what we've defined in our application.properties file.

Once the producer is up and running, you can send a message to the test topic like this:

If everything is working correctly, you should see the message being logged through the Spring application like this:

Spring Boot Kafka Consumer example including consumer offsets and multiple consumer examples.

Spring Boot Kafka Consumer

Autowire in Spring including what is autowiring, dependency injection, why we use autowiring, and examples.

The 5 Minute Guide to Autowire in Spring

What is the difference between TLS and HTTP?

What is the bootstrap server in Kafka?

Is Kafka better than RabbitMQ?

How does a consumer work in Kafka?

I am trying to use the JSON deserializer for Kafka (with Spring) and keep having issues.  Specifically it seems to throw the service into an infinite loop resulting in out of memory error...

Does anyone have issues with JSON Serializer in Kafka

One To One Example | Spring Data JPA

Quick Start | Spring Data JPA

Spring Boot Kafka Consumer JSON Example

Spring Boot Kafka Interview Questions

Spring Boot Kafka Consumer

The 5 Minute Guide to Autowire in Spring

Trending