Interview ‐ Spring Data (JpaRepository, MongoRepository) - Yash-777/MyWorld GitHub Wiki

package org.springframework.data.jpa.repository;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;
@org.springframework.data.repository.NoRepositoryBean
public interface JpaRepository<T, ID> extends 
                       PagingAndSortingRepository<T, ID>,
                       QueryByExampleExecutor<T> {
    @Override
    List<T> findAll();
    @Override
    List<T> findAll(Sort sort);
    @Override
    List<T> findAllById(Iterable<ID> ids);
    @Override
    <S extends T> List<S> saveAll(Iterable<S> entities);
    // Flushes all pending changes to the database.
    void flush();
    // Saves an entity and flushes changes instantly.
    <S extends T> S saveAndFlush(S entity);
    void deleteInBatch(Iterable<T> entities);
    void deleteAllInBatch();
    T getOne(ID id);
    @Override
    <S extends T> List<S> findAll(Example<S> example);
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

package org.springframework.data.mongodb.repository;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;
@org.springframework.data.repository.NoRepositoryBean
public interface MongoRepository<T, ID> extends 
                       PagingAndSortingRepository<T, ID>,
                       QueryByExampleExecutor<T> {
    @Override
    <S extends T> List<S> saveAll(Iterable<S> entities);
    @Override
    List<T> findAll();
    @Override
    List<T> findAll(Sort sort);
    <S extends T> S insert(S entity);
    <S extends T> List<S> insert(Iterable<S> entities);
    @Override
    <S extends T> List<S> findAll(Example<S> example);
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

package org.springframework.data.repository;

// ── Paging & Sorting ──────────────────────────────────────────────────────────
@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    Iterable<T> findAll(org.springframework.data.domain.Sort sort);      // All records, sorted
    Page<T> findAll(org.springframework.data.domain.Pageable pageable);  // Paginated + sorted result
}
// ── Basic CRUD ────────────────────────────────────────────────────────────────
@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S entity);                          // Insert or Update (upsert)
    <S extends T> Iterable<S> saveAll(Iterable<S> entities); // Bulk upsert
    Optional<T> findById(ID id);                             // Find by PK → Optional (never null)
    boolean existsById(ID id);                               // Check existence by PK
    Iterable<T> findAll();                                   // Fetch all records
    Iterable<T> findAllById(Iterable<ID> ids);               // Fetch by list of PKs
    long count();                                            // Total row/document count
    void deleteById(ID id);                                  // Delete by PK
    void delete(T entity);                                   // Delete given entity
    void deleteAll(Iterable<? extends T> entities);          // Delete given list
    void deleteAll();                                        // Delete everything — USE WITH CAUTION
}
// ── Marker interface ──────────────────────────────────────────────────────────
@Indexed
public interface Repository<T, ID> { }

package com.example.shop.entity;

/**
 * Abstract base for all JPA entities.
 *
 * @MappedSuperclass   — Fields are inherited into child entity tables (no separate table created).
 * @EntityListeners    — Activates Spring's JPA auditing for @CreatedDate / @LastModifiedDate.
 */
@Getter @Setter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    @org.springframework.data.annotation.Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // Auto-increment PK (Long)
    private Long id;

    @Column(name = "active_status", nullable = false)
    private boolean activeStatus = true;

    @org.springframework.data.annotation.CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;

    @org.springframework.data.annotation.LastModifiedDate
    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;
}

package com.example.shop.document;

/**
 * Abstract base for all MongoDB documents.
 *
 * @Id — Maps to MongoDB's _id field. Spring stores the ObjectId as a String.
 *       Unlike JPA, there is no @GeneratedValue — MongoDB generates ObjectId automatically.
 *
 * No @MappedSuperclass needed — MongoDB has no schema inheritance constraint.
 * No @EntityListeners needed — @EnableMongoAuditing handles @CreatedDate / @LastModifiedDate.
 * @Getter / @Setter   — Lombok: generates all getters and setters automatically.
 */
@Getter @Setter
public abstract class BaseDocument implements Serializable {
    private static final long serialVersionUID = 1L;

    @org.springframework.data.annotation.Id
    private String id;  // MongoDB ObjectId (auto-generated as 24-char hex string)

    private boolean active = true;

    @org.springframework.data.annotation.CreatedDate
    private LocalDateTime createdAt;

    @org.springframework.data.annotation.LastModifiedDate
    private LocalDateTime updatedAt;
}

package com.example.shop.entity;

import javax.persistence.*;

/**
 * Maps to the "products" table in the SQL database.
 *
 * @Entity             — Marks this class as a JPA-managed table.
 * @Table              — Specifies the exact table name in the DB.
 * @Getter / @Setter   — Lombok: all getters & setters.
 * @NoArgsConstructor  — Lombok: no-arg constructor (required by JPA).
 * @AllArgsConstructor — Lombok: constructor with all fields.
 * @Builder            — Lombok: fluent builder pattern  e.g. ProductEntity.builder().name("X").build()
 * @ToString           — Lombok: generates toString() (excludes BaseEntity fields via callSuper=false)
 */
@Getter @Setter @NoArgsConstructor @AllArgsConstructor @Builder @ToString @Entity
@Table(name = "products")
public class ProductEntity extends BaseEntity {
    private static final long serialVersionUID = 2L;

    @Column(name = "product_name", nullable = false)
    private String name;
    @Column(name = "category")
    private String category;
    @Column(name = "price", nullable = false)
    private double price;
    @Column(name = "stock_quantity")
    private int stockQuantity;
    @Column(name = "sku", unique = true)
    private String sku;  // Stock Keeping Unit — unique product code
}

package com.example.shop.document;

public enum OrderStatus {
    PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED
}
/**
 * Embedded object stored inside OrderDocument as a nested BSON field.
 * NOT a separate MongoDB collection — no @Document annotation.
 *
 * @Data = @Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor
 */
@Data @NoArgsConstructor @AllArgsConstructor @Builder
public class OrderItem {
    private String sku;
    private String productName;
    private int quantity;
    private double unitPrice;

    // Derived field — not stored in DB, computed on read
    public double getTotalPrice() {
        return quantity * unitPrice;
    }
}

/**
 * Maps to the "orders" collection in MongoDB.
 *
 * @org.springframework.data.mongodb.core.mapping.Document(collection = "orders")
 *   Equivalent of @Entity + @Table in JPA.
 *   Specifies the MongoDB collection name explicitly.
 *
 * @com.fasterxml.jackson.annotation.JsonIgnoreProperties({"createdAt","updatedAt"})
 *   Excludes audit fields from JSON REST responses.
 *
 * @Indexed — Creates a MongoDB index on the annotated field for faster queries.
 */
@Data @NoArgsConstructor @AllArgsConstructor @Builder
@org.springframework.data.mongodb.core.mapping.Document(collection = "orders")
@JsonIgnoreProperties({ "createdAt", "updatedAt" })
public class OrderDocument extends BaseDocument {
    private static final long serialVersionUID = 2L;

    @org.springframework.data.mongodb.core.index.Indexed  // MongoDB index — speeds up queries by customerId
    private String customerId;
    private String customerName;
    private List<OrderItem> items; // Embedded list of sub-documents (no separate collection)
    private OrderStatus status;
    private double totalAmount;
    private String deliveryAddress;
    private String remarks;
}

package com.example.shop.repository;

import com.example.shop.entity.BaseEntity;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * @NoRepositoryBean — Spring will NOT instantiate this interface as a bean.
 *                     Only concrete child interfaces get Spring-managed beans.
 *
 * Generic bound  ensures only proper entities extend this.
 */
@org.springframework.data.repository.NoRepositoryBean
public interface BaseRepository<E extends BaseEntity>
        extends JpaRepository<E, Long> {
    // Shared custom query methods go here (e.g. findAllByActiveStatus)
}

import com.example.shop.entity.ProductEntity;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

/**
 * Spring creates a bean for this interface (it is concrete, not @NoRepositoryBean).
 * All CRUD + paging + sorting methods are inherited automatically.
 */
@Repository
public interface ProductRepository extends BaseRepository<ProductEntity> {

    // Derived query — Spring generates: WHERE category = ? AND active_status = ?
    List<ProductEntity> findByCategoryAndActiveStatus(
            @Param("category") String category,
            @Param("activeStatus") boolean activeStatus);

    // Derived query — Spring generates: WHERE sku = ?
    Optional<ProductEntity> findBySku(@Param("sku") String sku);

    // Derived count — Spring generates: SELECT COUNT(*) WHERE category = ?
    long countByCategory(@Param("category") String category);

    // Derived exists — Spring generates: SELECT CASE WHEN COUNT(*) > 0 WHERE sku = ?
    boolean existsBySku(@Param("sku") String sku);
}

package com.example.shop.repository;

import com.example.shop.document.BaseDocument;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.repository.NoRepositoryBean;

/**
 * @NoRepositoryBean — Spring will NOT create a bean for this interface.
 *
 * ID is String because MongoDB ObjectId is serialized as a 24-char hex String.
 */
@NoRepositoryBean
public interface BaseDocumentRepository<D extends BaseDocument>
        extends MongoRepository<D, String> {
    // Shared Mongo query methods can go here
}

import com.example.shop.document.OrderDocument;
import com.example.shop.document.OrderStatus;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderRepository extends BaseDocumentRepository<OrderDocument> {

    // Derived query — WHERE customerId = ?
    List<OrderDocument> findByCustomerId(@Param("customerId") String customerId);

    // Derived query — WHERE customerId = ? AND status = ?
    List<OrderDocument> findByCustomerIdAndStatus(
            @Param("customerId") String customerId,
            @Param("status") OrderStatus status);

    // Derived count — SELECT COUNT(*) WHERE status = ?
    long countByStatus(@Param("status") OrderStatus status);

    // Derived exists — WHERE customerId = ?
    boolean existsByCustomerId(@Param("customerId") String customerId);
}

package com.example.shop;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.data.mongodb.config.EnableMongoAuditing;

@SpringBootApplication
@EnableJpaAuditing       // Activates @CreatedDate / @LastModifiedDate for JPA entities
@EnableMongoAuditing     // Activates @CreatedDate / @LastModifiedDate for Mongo documents
public class ShopApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShopApplication.class, args);
    }
}