most used methods with simple example

most used methods with simple example

In JPA, there are several commonly used methods provided by the EntityManager interface and the Query interface for performing CRUD operations and querying the database. Here are some of the most frequently used methods:

most used methods with simple example

  • 1.  persist() : Used to save a new entity to the database.
  • 2.  find() : Retrieves an entity by its primary key.
  • 3.  merge() : Updates an existing entity or saves a new entity if it does not exist.
  • 4.  remove() : Deletes an entity from the database.
  • 5.  createQuery() : Creates a JPQL query.
  • 6.  createNamedQuery() : Creates a named query defined in the entity class.
  • 7.  createNativeQuery() : Creates a native SQL query.
  • 8.  getResultList() : Executes a query and returns the result as a list.
  • 9.  getSingleResult() : Executes a query and returns a single result.
  • 10.  setParameter() : Sets a parameter in a query.

Example

Below are examples demonstrating the usage of these methods.

Step 1: Define the Entity
java
package com.example.demo.model;

import javax.persistence.*;

@Entity
@NamedQuery(name = "Student.findByAge", query = "SELECT s FROM Student s WHERE s.age = :age")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int age;

    // Constructors, getters, and setters

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Step 2: Define the Service
java
package com.example.demo.service;

import com.example.demo.model.Student;

import javax.persistence.*;
import javax.transaction.Transactional;
import java.util.List;

public class StudentService {

    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void createStudent(Student student) {
        entityManager.persist(student); // persist()
    }

    public Student findStudent(Long id) {
        return entityManager.find(Student.class, id); // find()
    }

    @Transactional
    public Student updateStudent(Student student) {
        return entityManager.merge(student); // merge()
    }

    @Transactional
    public void deleteStudent(Long id) {
        Student student = entityManager.find(Student.class, id);
        if (student != null) {
            entityManager.remove(student); // remove()
        }
    }

    public List<Student> findStudentsUsingJPQL(int age) {
        String jpql = "SELECT s FROM Student s WHERE s.age > :age";
        TypedQuery<Student> query = entityManager.createQuery(jpql, Student.class); // createQuery()
        query.setParameter("age", age); // setParameter()
        return query.getResultList(); // getResultList()
    }

    public List<Student> findStudentsUsingNamedQuery(int age) {
        TypedQuery<Student> query = entityManager.createNamedQuery("Student.findByAge", Student.class); // createNamedQuery()
        query.setParameter("age", age); // setParameter()
        return query.getResultList(); // getResultList()
    }

    public List<Student> findStudentsUsingNativeQuery(int age) {
        String sql = "SELECT * FROM students WHERE age > ?";
        Query query = entityManager.createNativeQuery(sql, Student.class); // createNativeQuery()
        query.setParameter(1, age); // setParameter()
        return query.getResultList(); // getResultList()
    }
}

Step 3: Define the Controller
java
package com.example.demo.controller;

import com.example.demo.model.Student;
import com.example.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @PostMapping
    public void createStudent(@RequestBody Student student) {
        studentService.createStudent(student);
    }

    @GetMapping("/{id}")
    public Student findStudent(@PathVariable Long id) {
        return studentService.findStudent(id);
    }

    @PutMapping
    public Student updateStudent(@RequestBody Student student) {
        return studentService.updateStudent(student);
    }

    @DeleteMapping("/{id}")
    public void deleteStudent(@PathVariable Long id) {
        studentService.deleteStudent(id);
    }

    @GetMapping("/jpql")
    public List<Student> findStudentsUsingJPQL(@RequestParam int age) {
        return studentService.findStudentsUsingJPQL(age);
    }

    @GetMapping("/named")
    public List<Student> findStudentsUsingNamedQuery(@RequestParam int age) {
        return studentService.findStudentsUsingNamedQuery(age);
    }

    @GetMapping("/native")
    public List<Student> findStudentsUsingNativeQuery(@RequestParam int age) {
        return studentService.findStudentsUsingNativeQuery(age);
    }
}

Summary

Here are the most used methods in JPA with simple examples:

  • persist() : Saves a new entity to the database.
    •   java
    •   entityManager.persist(student);
  • find() : Retrieves an entity by its primary key.
    •   java
    •   Student student = entityManager.find(Student.class, id);
  • merge() : Updates an existing entity or saves a new one if it does not exist.
    •   java
    •   Student updatedStudent = entityManager.merge(student);
  • remove() : Deletes an entity from the database.
    •   java
    •   entityManager.remove(student);
  • createQuery() : Creates a JPQL query.
    •   java
    •   TypedQuery<Student> query = entityManager.createQuery(“SELECT s FROM Student s”, Student.class);
  • createNamedQuery() : Creates a named query.
    •   java
    •   TypedQuery<Student> query = entityManager.createNamedQuery(“Student.findByAge”, Student.class);
  • createNativeQuery() : Creates a native SQL query.
    •   java
    •   Query query = entityManager.createNativeQuery(“SELECT * FROM students”, Student.class);
  • getResultList() : Executes a query and returns the result as a list.
    •   java
    •   List<Student> students = query.getResultList();
  • getSingleResult() : Executes a query and returns a single result.
    •   java
    •   Student student = query.getSingleResult();
  • setParameter() : Sets a parameter in a query.
    •   java
    •   query.setParameter(“age”, age);