Gain insights into integrating Spring Data with relational, NoSQL, graph, and distributed databases. Discover how to leverage Spring Data for seamless application and data service interactions.

spring_data.tar.gz

spring_data_chapter1

spring_data_jdbc_chapter3

spring_data_jpa_chapter4

spring_data_mongodb_chapter5

spring_data_redis_chapter6

spring_data_couchbase_chapter7

spring_data_elasticsearch_chapter8

spring_data_neo4j_chapter9

spring_data_cassandra_chapter10

spring_data_geode_chapter11

spring_data_solr_chapter12

spring_data_chapter2

spring_data_mongodb_chapter5-transaction

This course will teach you how to seamlessly integrate Spring Data with various data sources, including relational and nonrelational databases, map-reduce frameworks, and cloud-based data services. 

You’ll start this course by exploring Spring Data JDBC and Spring Data JPA for efficient access to relational databases. Next, you’ll dive into NoSQL databases with Spring Data MongoDB and Spring Data Redis, venture into graph databases with Spring Data Neo4j, and explore the world of distributed databases with Spring Data for Apache Cassandra. Lastly, you’ll discover the power of Spring Data Elasticsearch. 

By the end of this course, you’ll emerge equipped with the knowledge and skills to leverage Spring Data effectively in diverse data-driven scenarios. You’ll be able to create applications seamlessly integrated with various data sources. This proficiency in Spring Data will enable you to design, build, and maintain applications that interact effortlessly with databases and data services.

Spring Data: Bridging Multiple Databases

In Spring Data JPA, entities represent the persistent data model, typically annotated with JPA annotations for mapping to database tables. Repositories provide a convenient way to interact with the database, offering predefined methods for CRUD operations and custom query creation.

In this lesson, we'll use the same example of the `Book` and `Author` POJO referencing the `book` and `author` database tables and convert them into JPA entities.

Let’s learn a few handy annotations to transform a POJO into an entity.

The most common annotations are `@Entity` and `@Id`.

* The `@Entity` annotation allows mapping a POJO to a database table with the underlying data access layer.

* The `@Id` annotation allows mapping property to a primary key in the database table.

We use these annotations to convert the `Book` POJO from the `com.smartdiscover.entity` package to an entity and map it to the `Book` table.


package com.smartdiscover.entity;

import jakarta.persistence.*;
import lombok.Data;

import java.util.List;
import java.util.stream.Collectors;

@Data
@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private String summary;

    @ManyToMany
    @JoinTable(
            name = "book_authors",
            joinColumns = @JoinColumn(name = "book_id"),
            inverseJoinColumns = @JoinColumn(name = "author_id"))
    private List<Author> authors;

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", summary='" + summary + '\'' +
                ", authors='" + authors.stream().map(i-> i.getFullName()).collect(Collectors.toList()) + '\'' +
                '}';
    }
}

Explanation:

* **Lines 13 and 14:** The `long` type property `id` is a unique identifier for which we want to automatically generate the value when an instance persists in the database. So, we use the `@GeneratedValue` annotation to define the `AUTO` value for the `GenerationType`, allowing the JPA to choose the appropriate strategy for `id` generation for the `H2` database. Besides `AUTO`, other properties such as `IDENTITY`, `SEQUENCE`, and `TABLE` are available for generation strategies for a primary key.

* **Lines 20 and 24:** We declare the `many-to-many` mapping to the `authors` list using the `@ManyToMany` and `@JoinColumn` annotations provided by JPA.

Explore entities and repositories through the Spring Data JPA framework.

Introduction to Spring Data

Spring Data in Detail

Spring Data JDBC

Spring Data JPA

Build a Full Stack Application Using Spring Boot and Thymeleaf

Spring Data MongoDB

Spring Data Redis

Spring Data Couchbase

Spring Data Neo4j

Spring Data for Apache Cassandra

Spring Data Elasticsearch

Bank Management System

Wrapping Up

JPA Entities and Repositories