Spring Data JPA JpaRepository saveAndFlush() Example

In this post, we will see Spring Data JPA JpaRepository saveAndFlush() example using Spring Boot and Oracle.

The saveAndFlush() method is defined in JpaRepository interface as below.

<S extends T> S saveAndFlush(S entity)

The JpaRepository saveAndFlush() method saves an entity and flushes changes instantly. Internally saveAndFlush() uses save() and flush() method only.

	public <S extends T> S saveAndFlush(S entity) {

		S result = save(entity);
		flush();

		return result;
	}

Note – JpaRepository interface extends PagingAndSortingRepository interface which further extends CrudRepository. CrudRepository extends Repository interface.

In Spring Data JPA Repository is the top-level interface in hierarchy.

JPA JpaRepository saveAndFlush()

Let’s see in below code how we are going to use the JpaRepository saveAndFlush() method.

package com.netsurfingzone.impl;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.netsurfingzone.entity.Student;
import com.netsurfingzone.repository.StudentRepository;
import com.netsurfingzone.service.StudentService;

@Service("studentServiceImpl")
public class StudentServiceImpl implements StudentService {

	@Autowired
	private StudentRepository studentRepository;

	@Transactional
	public Student saveAndFlushStudent(Student student) {
		Student response =  studentRepository.saveAndFlush(student);
		return response;
	}

	@Transactional(readOnly = true)
	public Student getStudent(int id ) {
		Optional<Student> studentResponse =  studentRepository.findById(id);
		Student student = studentResponse.get();
		return student;
	}
	
}

Note – We are using @Transactional annotation in the above example. See more details about about @Transactional annotation here.

Let’s see an example of Spring Data JPA JpaRepository saveAndFlush() Method.

Open eclipse and create maven project, Don’t forget to check ‘Create a simple project (skip)’ click on next.  Fill all details(GroupId – springdatasaveandflush, ArtifactId – springdatasaveandflush and name – springdatasaveandflush) and click on finish. Keep packaging as the jar.

Modify 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>springdatasaveandflush</groupId>
	<artifactId>springdatasaveandflush</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springdatasaveandflush</name>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.2.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>

		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

		<dependency>
			<groupId>com.oracle</groupId>
			<artifactId>ojdbc6</artifactId>
			<version>11.2.0.3</version>
		</dependency>

	</dependencies>
	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>

			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<fork>true</fork>
					<executable>C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe</executable>
				</configuration>
			</plugin>


		</plugins>
	</build>
</project>

Note – In pom.xml we have defined javac.exe path in configuration tag. You need to change accordingly i.e where you have installed JDK.

If you see any error for oracle dependency then follow these steps.

Directory structure –

Spring Data CrudRepository save() Method

Student.java

package com.netsurfingzone.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Student {

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

	@Column(name = "name")
	private String name;

	@Column(name = "roll_number")
	private String rollNumber;

	@Column(name = "university")
	String university;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getRollNumber() {
		return rollNumber;
	}

	public void setRollNumber(String rollNumber) {
		this.rollNumber = rollNumber;
	}

	public String getUniversity() {
		return university;
	}

	public void setUniversity(String university) {
		this.university = university;
	}

}

StudentController.java

package com.netsurfingzone.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.netsurfingzone.entity.Student;
import com.netsurfingzone.service.StudentService;

@RestController
@RequestMapping(value = "/student")
public class StudentController {

	@Autowired
	private StudentService studentService;

	@RequestMapping(value = "/saveandflush", method = RequestMethod.POST)
	@ResponseBody
	public Student save(@RequestBody Student student) {
		Student studentResponse = (Student) studentService.saveAndFlushStudent(student);
		return studentResponse;
	}

	@RequestMapping(value = "/{id}", method = RequestMethod.GET)
	@ResponseBody
	public Student getStudent(@PathVariable int id) {
		Student studentResponse = (Student) studentService.getStudent(id);
		return studentResponse;
	}

}

StudentRepository.java – interface

package com.netsurfingzone.repository;

import java.io.Serializable;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.netsurfingzone.entity.Student;

@Repository
public interface StudentRepository extends JpaRepository<Student, Serializable> {

}

StudentService.java – interface

package com.netsurfingzone.service;

import org.springframework.stereotype.Component;

import com.netsurfingzone.entity.Student;

@Component
public interface StudentService {
	public Student saveAndFlushStudent(Student student);

	public Student getStudent(int id);

}

Note – See here more about @Component, @Controller, @Service and @Repository annotations here.


StudentServiceImpl.java

package com.netsurfingzone.impl;

import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.netsurfingzone.entity.Student;
import com.netsurfingzone.repository.StudentRepository;
import com.netsurfingzone.service.StudentService;

@Service("studentServiceImpl")
public class StudentServiceImpl implements StudentService {

	@Autowired
	private StudentRepository studentRepository;

	@Transactional
	public Student saveAndFlushStudent(Student student) {
		Student response =  studentRepository.saveAndFlush(student);
		return response;
	}

	@Transactional(readOnly = true)
	public Student getStudent(int id ) {
		Optional<Student> studentResponse =  studentRepository.findById(id);
		Student student = studentResponse.get();
		return student;
	}
	
}

SpringMain.java

package com.netsurfingzone.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages = "com.*")
@EntityScan("com.netsurfingzone.entity")
public class SpringMain {
	public static void main(String[] args) {

		SpringApplication.run(SpringMain.class, args);
	}

}

JpaConfig.java

package com.netsurfingzone.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration
@EnableJpaRepositories(basePackages = "com.netsurfingzone.repository")
public class JpaConfig {

}

Note – See more details about @Configuration annotations here.


application.properties

# Connection url for the database
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=SYSTEM
spring.datasource.password=oracle2
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
# Show or not log for each sql query
spring.jpa.show-sql = true
 
 
spring.jpa.hibernate.ddl-auto =create
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.Oracle10gDialect
 
server.port = 9091

Let’s run the SpringMain class(run as java application).

Perform save operation first using below REST API.

Perform save operation first using below REST API.

http://localhost:9091/student/saveandflush

Request Data –

 {

        "name": "Hiteshdo",
        "rollNumber": "0126CS01",
        "university": "rgtu"
}

Response data –

{
    "id": 1,
    "name": "Hiteshdo",
    "rollNumber": "0126CS01",
    "university": "rgtu"
}

Get operation.

API -http://localhost:9091/student/{id}

http://localhost:9091/student/1
Spring Data CrudRepository existsById()

That’s all about Spring Data JPA JpaRepository saveAndFlush() Example

You may like.

Other Spring Data JPA and Hibernate tutorials.

Spring Data JPA saveAndFlush() docs.

Summary – Spring Data JpaRepository saveAndFlush() method saves an entity and flushes changes instantly. Internally saveAndFlush() uses save() and flush() method only.