Devops Monk

public interface CrudRepository<T, ID> {
    <S extends T> S save(S entity);
    <S extends T> Iterable<S> saveAll(Iterable<S> entities);
    Optional<T> findById(ID id);
    boolean existsById(ID id);
    Iterable<T> findAll();
    Iterable<T> findAllById(Iterable<ID> ids);
    long count();
    void deleteById(ID id);
    void delete(T entity);
    void deleteAllById(Iterable<? extends ID> ids);
    void deleteAll(Iterable<? extends T> entities);
    void deleteAll();
}

public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
    Iterable<T> findAll(Sort sort);
    Page<T> findAll(Pageable pageable);
}

public interface JpaRepository<T, ID>
        extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {

    List<T> findAll();
    List<T> findAll(Sort sort);
    List<T> findAllById(Iterable<ID> ids);
    <S extends T> List<S> saveAll(Iterable<S> entities);
    void flush();
    <S extends T> S saveAndFlush(S entity);
    <S extends T> List<S> saveAllAndFlush(Iterable<S> entities);
    void deleteAllInBatch(Iterable<T> entities);
    void deleteAllByIdInBatch(Iterable<ID> ids);
    void deleteAllInBatch();
    T getReferenceById(ID id);
    <S extends T> List<S> findAll(Example<S> example);
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

package com.devopsmonk.jpademo.repository;

import com.devopsmonk.jpademo.domain.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
    // Empty interface — Spring generates all JpaRepository methods automatically
}

@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductRepository productRepository;

    // Create
    @Transactional
    public Product create(String name, BigDecimal price) {
        Product product = new Product();
        product.setName(name);
        product.setPrice(price);
        return productRepository.save(product);
    }

    // Read
    public Product findById(Long id) {
        return productRepository.findById(id)
            .orElseThrow(() -> new EntityNotFoundException("Product not found: " + id));
    }

    // Read all
    public List<Product> findAll() {
        return productRepository.findAll();
    }

    // Update
    @Transactional
    public Product updatePrice(Long id, BigDecimal newPrice) {
        Product product = productRepository.findById(id).orElseThrow();
        product.setPrice(newPrice);
        // dirty checking — no explicit save() needed within @Transactional
        return product;
    }

    // Delete
    @Transactional
    public void delete(Long id) {
        productRepository.deleteById(id);
    }

    // Check existence
    public boolean exists(Long id) {
        return productRepository.existsById(id);
    }

    // Count
    public long count() {
        return productRepository.count();
    }
}

// save() — SQL runs at transaction commit
Product saved = productRepository.save(product);
// saved.getId() is populated (Hibernate executed INSERT for IDENTITY strategy)
// but surrounding queries in the same tx might not see this yet

// saveAndFlush() — SQL runs immediately, result visible to subsequent queries
Product saved = productRepository.saveAndFlush(product);
// guaranteed visible to all subsequent queries in this transaction

// deleteAll() — loads all entities into memory, then deletes one by one
productRepository.deleteAll();
// SQL: SELECT * FROM products
//      DELETE FROM products WHERE id = 1
//      DELETE FROM products WHERE id = 2
//      ... (N SQL statements)

// deleteAllInBatch() — single SQL, no entities loaded into memory
productRepository.deleteAllInBatch();
// SQL: DELETE FROM products

@Transactional
public OrderItem createItem(Long orderId, Long productId, int quantity) {
    // getReferenceById — no SELECT for order or product
    Order order = orderRepository.getReferenceById(orderId);
    Product product = productRepository.getReferenceById(productId);

    OrderItem item = new OrderItem();
    item.setOrder(order);        // sets the FK reference via proxy
    item.setProduct(product);
    item.setQuantity(quantity);
    item.setUnitPrice(product.getPrice()); // this triggers product proxy load

    return itemRepository.save(item);
}

public interface ProductRepository
        extends JpaRepository<Product, Long>,
                JpaSpecificationExecutor<Product> {
    // JpaSpecificationExecutor adds: findAll(Specification), findOne(Specification), count(Specification)
}