Complete tutorial of building Spring REST API with Hibernate and JPA using Second Level Cache showing Hit and Miss.

<web-app>
    <display-name>Spring REST API with Hibernate and JPA with Second Level Cache</display-name>
    <servlet>
        <servlet-name>SpringRESTAPIHibernateJpaSecondLevelCache</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/myApplicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringRESTAPIHibernateJpaSecondLevelCache</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>
        

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <context:component-scan base-package="controller,repository"/>
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean"/>
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
</beans>
        

<persistence version="2.2" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
    <persistence-unit name="myPersistenceUnit">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>repository.CustomerEntity</class>
        <properties>
            <property name="hibernate.connection.driver_class" value="com.mysql.cj.jdbc.Driver"/>
            <property name="hibernate.connection.username" value="myuser"/>
            <property name="hibernate.connection.password" value="mypassword"/>
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/mydb"/>
            <property name="hibernate.c3p0.max_size" value="50"/>
            <property name="hibernate.c3p0.timeout" value="300"/>
            <property name="hibernate.cache.use_second_level_cache" value="true"/>
            <property name="hibernate.javax.cache.missing_cache_strategy" value="create"/>
            <property name="hibernate.javax.cache.provider" value="org.ehcache.jsr107.EhcacheCachingProvider"/>
            <property name="hibernate.generate_statistics" value="true"/>
        </properties>
    </persistence-unit>
</persistence>
        

package controller;

import model.Stat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import model.Customer;
import repository.CustomerRepository;

@RestController
@RequestMapping("/myapp")
public class MyController {

    @Autowired
    private CustomerRepository customerRepository;

    @GetMapping("/stat")
    public Stat getStat() {

        return customerRepository.getStat();
    }

    @GetMapping("/customer")
    public Customer getCustomer(@RequestParam("name") String name) {

        Customer customer = customerRepository.getCustomerByName(name);

        return customer;
    }

    @PostMapping("/customer")
    public void postCustomer(@RequestBody Customer customer) {

        customerRepository.saveCustomer(customer);
    }
}
            

package model;

import lombok.Data;

@Data
public class Customer {

    private String name;
    private String email;
}
        

package model;

import lombok.Data;

@Data
public class Stat {

    private long secondLevelCacheHitCount;
    private long secondLevelCacheMissCount;
}
        

package repository;

import lombok.Data;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import jakarta.persistence.*;
import java.util.Date;

@Data
@Entity
@Table(name="Customer")
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class CustomerEntity {

    @Id
    @Column(name="Name", length=50, nullable=false)
    private String name;

    @Basic
    @Column(name="Email")
    private String email;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="CreatedDate")
    private Date createdDate;
}

        

package repository;

import model.Customer;
import model.Stat;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.*;
import org.springframework.transaction.annotation.Transactional;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import java.util.Date;

@Repository
public class CustomerRepository {

    @PersistenceContext(name="myPersistenceUnit")
    public EntityManager entityManager;

    public Stat getStat() {

        SessionFactory sessionFactory = entityManager.getEntityManagerFactory().unwrap(SessionFactory.class);
        long cacheHit = sessionFactory.getStatistics().getSecondLevelCacheHitCount();
        long cacheMiss = sessionFactory.getStatistics().getSecondLevelCacheMissCount();

        Stat stat = new Stat();
        stat.setSecondLevelCacheHitCount(cacheHit);
        stat.setSecondLevelCacheMissCount(cacheMiss);

        return stat;
    }

    public Customer getCustomerByName(String name) {

        CustomerEntity customerEntity = entityManager.find(CustomerEntity.class, name);

        Customer customer = new Customer();
        if (customerEntity != null) {
            customer.setEmail(customerEntity.getEmail());
            customer.setName(customerEntity.getName());
        }

        return customer;
    }

    @Transactional
    public void saveCustomer(Customer customer) {

        CustomerEntity customerEntity = new CustomerEntity();
        customerEntity.setName(customer.getName());
        customerEntity.setEmail(customer.getEmail());
        customerEntity.setCreatedDate(new Date());

        entityManager.persist(customerEntity);
    }
}