# Creating a Simple Application with Spring Boot and JPA Repository

This tutorial is part of [Springing into Action: A Spring Boot Journey from Novice to Pro](https://amrtechuniverse.com/series/springboot-novice-to-pro) Series, be sure to check it out for more related content!

In this tutorial, we will learn how to create a simple application using Spring Boot and JPA Repository, including pagination. We will use a MySQL database to persist our data and will create a REST API to perform CRUD operations on it.

## **Prerequisites**

* Java 8 or later
    
* Maven 3.x
    
* MySQL Server
    
* Spring Boot CLI
    
* An IDE like Eclipse or IntelliJ IDEA
    

## **Setting up the Project**

First, we need to create a new Spring Boot project using the Spring Initializer. We will select the following dependencies:

* Spring Web
    
* Spring Data JPA
    
* MySQL Driver
    

Once the project is generated, we can import it into our IDE and start adding our code.

## **Configuring the Database**

Next, we will configure our MySQL database by adding the following properties to our [`application.properties`](http://application.properties) file:

```java
spring.datasource.url=jdbc:mysql://<host>:<port>/<dbname>
spring.datasource.username=<username>
spring.datasource.password=<password>
```

Make sure to replace the placeholders with the appropriate values for your MySQL server.

## **Creating the Entity**

We will create two entities, `Student` and `Course`, to represent our data. The `Student` entity will have a one-to-many relationship with the `Course` entity.

```java
@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Course> courses;
    // getters and setters
}
```

```java
@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    @ManyToOne
    @JoinColumn(name = "student_id")
    private Student student;
    // getters and setters
}
```

## **Creating the Repository**

We will create a JPA repository for each entity to perform CRUD operations on our data.

```java
public interface StudentRepository extends JpaRepository<Student, Long> {
}
```

```java
public interface CourseRepository extends JpaRepository<Course, Long> {
}
```

## **Creating the REST API**

We will create a REST controller for each entity to handle the HTTP requests.

```java
@RestController
@RequestMapping("/students")
public class StudentController {
    @Autowired
    private StudentRepository studentRepository;
    @Autowired
    private CourseRepository courseRepository;

    @GetMapping
    public Page<Student> getAllStudents(Pageable pageable) {
        return studentRepository.findAll(pageable);
    }

    @PostMapping
    public Student addStudent(@RequestBody Student student) {
        return studentRepository.save(student);
    }

    @PutMapping("/{studentId}")
    public Student updateStudent(@PathVariable Long studentId, @RequestBodyStudent student) {
 student.setId(studentId); return studentRepository.save(student); }

@DeleteMapping("/{studentId}")
public void deleteStudent(@PathVariable Long studentId) {
    studentRepository.deleteById(studentId);
}

@GetMapping("/{studentId}/courses")
public List<Course> getStudentCourses(@PathVariable Long studentId) {
    return courseRepository.findByStudentId(studentId);
}
}
```

```java

@RestController
@RequestMapping("/courses")
public class CourseController {
    @Autowired
    private CourseRepository courseRepository;

    @GetMapping
    public Page<Course> getAllCourses(Pageable pageable) {
        return courseRepository.findAll(pageable);
    }

    @PostMapping
    public Course addCourse(@RequestBody Course course) {
        return courseRepository.save(course);
    }

    @PutMapping("/{courseId}")
    public Course updateCourse(@PathVariable Long courseId, @RequestBody Course course) {
        course.setId(courseId);
        return courseRepository.save(course);
    }

    @DeleteMapping("/{courseId}")
    public void deleteCourse(@PathVariable Long courseId) {
        courseRepository.deleteById(courseId);
    }
}
```

In the above code examples, we have added pagination by passing a `Pageable` object to our repository's `findAll()` method. This allows us to retrieve a specific page of data from our database.

## **Running the Application**

Once the project is set up, we can run it using the following command:

```java
mvn spring-boot:run
```

We can now test our REST API by sending HTTP requests to the appropriate endpoints.

In this tutorial, we have learned how to create a simple application using Spring Boot and JPA Repository, including pagination. We have also seen how easy it is to perform CRUD operations on a MySQL database using this framework.

I hope you found this tutorial helpful, and that you can use this as a starting point for your next project.

Note: above code is a simplified version for demonstration purposes, it's not ready to use code, you may need to customize it according to your requirement.