Home Spring Boot Spring Data JDBC - One-to-Many Example

Spring Data JDBC – One-to-Many Example

A basic quick Spring Data JDBC example on how to map One-toMany database tables relation in entities.

1. Database Tables

Let’s have a look into following tables, We can say that the relation between BRANCH and STUDENT is One-to-Many. Each College Engineering Branch has multiple number of Students.

CREATE TABLE `BRANCH` (
  `BRANCH_ID` int(11) NOT NULL AUTO_INCREMENT,
  `BRANCH_SHORT_NAME` varchar(45) NOT NULL,
  `BRANCH_NAME` varchar(100) NOT NULL,
  `DESCRIPTION` varchar(200) DEFAULT NULL,
  PRIMARY KEY (`BRANCH_ID`)
);


CREATE TABLE `STUDENT` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `FIRST_NAME` varchar(45) DEFAULT NULL,
  `LAST_NAME` varchar(45) DEFAULT NULL,
  `CONTACT_NO` varchar(45) DEFAULT NULL,
  `BRANCH_ID` int(11) DEFAULT NULL,
  PRIMARY KEY (`ID`),
  CONSTRAINT `BRANCH_ID_FK` 
    FOREIGN KEY (`BRANCH_ID`) 
    REFERENCES `BRANCH` (`BRANCH_ID`)
);

2. Project Configuration

1.1. Used Technologies :

  1. Spring Boot 2.3.0.RELEASE
  2. Spring Data JDBC 2.0.0.RELEASE
  3. Spring Framework 5.2.6.RELEASE
  4. H2 / MySql DB
  5. Lombok 1.18.12
  6. JUnit 5

1.2. Maven Dependencies :

To start working with Spring Boot with Spring Data JDBC you need dependency spring-boot-starter-data-jdbc. Use Lombok to avoid boiler plate code. Here is complete dependency list used in the example application.

        <dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
		</dependency>
		<dependency>
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

3. Entities Mapping

3.1. Student entity :

@Data // lombok
public class Student {

	@Id
	private Long id;

	private String contactNo;
	private String firstName;
	private String lastName;

}

3.2. Branch Entity :

To map One-to-Many relation in Entity we have to use @MappedCollection on Collection like List or Set or Map.

@Data
public class Branch {

	@Id
	private int branchId;

	private String branchName;
	private String branchShortName;
	private String description;

	@MappedCollection(keyColumn = "BRANCH_ID", idColumn = "BRANCH_ID")
	private Set<Student> students;

}

4. Test the mapping

4.1. Create a JDBC Repository for Branch entity to perform basic database operations.

@Repository
public interface BranchOneToManyTestRepository extends CrudRepository<Branch, Long>{

}

4.2. Test Case

@SpringBootTest
public class OneToManyMappingTest extends BaseTest {

	@Autowired
	private BranchOneToManyTestRepository testRepository;

	@Test
	@DisplayName("One-to-Many Mapping Test")
	@Sql(scripts = "/one-to-many-mapping.sql")
	void embeddedMappingTest() {

		Branch branch = new Branch();
		branch.setBranchShortName("CSE");
		branch.setBranchName("Computer Science and Engineering");
		branch.setDescription("CSE department offers courses under ambitious curriculam in computer science and computer engineering..");
		Set<Student> students = new HashSet<>();
		students.add(getStudent1());
		students.add(getStudent2());
		branch.setStudents(students);

		Branch createdBranch = testRepository.save(branch);
		System.err.println(createdBranch);
		Assert.assertTrue(createdBranch != null);
	}

	private static Student getStudent1() {
		Student student = new Student();
		student.setFirstName("Rosy");
		student.setLastName("Larsen");
		student.setContactNo("+1-408-575-1317");

		return student;
	}

	private static Student getStudent2() {
		Student student = new Student();
		student.setFirstName("Rosy");
		student.setLastName("Larsen");
		student.setContactNo("+1-408-575-1219");

		return student;
	}
}

5. Conclusion

In this tutorial we have covered how to map One-to-Many association in Spring Data JDBC.

Checkout source code at Git Hub.

Other Spring Data JDBC Examples :

  1. Spring Data JDBC – Embedded Entities
  2. Spring Data JDBC – Pagination
  3. Spring Data JDBC – Many-to-Many
  4. Spring Data JDBC – One-to-One
  5. Spring Data JDBC – Query Derivation
  6. Spring Boot – Loading Initial data

6. References

  1. Spring Documentation
  2. Lombok @Data
  3. Hibernate One-to-Many Unidirectional
  4. Spring Boot Data JDBC Example
  5. Spring Boot H2 in-memory Database
Satish Varma
Satish Varmahttps://javabydeveloper.com
Satish is post graduated in master of computer applications and experienced software engineer with focus on Spring, JPA, REST, TDD and web development. Follow him on LinkedIn or Twitter or Facebook

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Stay in Touch

Categories