Java >> Java tutorial >  >> Tag >> Spring

Spring Boot – CRUD-operationer ved hjælp af JPA

I denne artikel vil vi bruge JPA (Java Persistence API) med Spring Boot til at indsætte, opdatere, slette og læse operationer.

Vi bruger H2-database i hukommelsen, men det samme kan ændres for enhver anden relationsdatabase.

Projektstruktur

Vi kan bruge Spring Tool Suite(STS) til at oprette et Spring-startprojekt og vælge h2- og jpa-afhængighederne.

Vi kan også bruge Spring Initializr til det samme (https://start.spring.io/).

pom.xml

Vi skal tilføje spring-boot-starter-data-jpa og h2-afhængighederne for at forbinde h2database ved hjælp af JPA.

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>

Enhed

Følgende Employee-enhedsklasse bruger JPA-annoteringer @Entity fra javax.persistence-pakken. Denne @Entity-annotation markerer klassen som Entity, der skal tilknyttes en databasetabel.

egenskaben Long id er markeret med annoteringer @Id og @GeneratedValue. Derfor vil id være den primære nøgle i tabellen og vil blive autogenereret.

package com.topjavatutorial.entity;

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

@Entity
public class Employee {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  Long id;
  String name;
  int age;

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

  public Employee() {

  }

  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;
  }

  public String toString() {
    StringBuffer sb = new StringBuffer("Employee(");
    sb.append("Id : ");
    sb.append(id);
    sb.append(", Name : ");
    sb.append(name);
    sb.append(", Age : ");
    sb.append(age);
    sb.append(")");
    return sb.toString();
  }

}

Service

Vi vil bruge følgende EmployeeService-klasse (annoteret med @Service) til at interagere med Employee-tabellen.

Den har funktioner til tilføjelse, opdatering, sletning og læsning af medarbejderregistreringer.

Denne klasse har en autowired EmployeeRepository-instans, hvorigennem vi vil udføre databaseinteraktioner.

package com.topjavatutorial.service;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.topjavatutorial.entity.Employee;
import com.topjavatutorial.repo.EmployeeRepository;

@Service
public class EmployeeService {
  private static final Logger log = LoggerFactory
      .getLogger(EmployeeService.class);

  @Autowired
  EmployeeRepository empRepo;

  public List<Employee> getAllEmployees() {
    log.info("inside EmployeeService.getAllEmployees");
    return empRepo.findAll();
  }

  public Employee getEmployeeById(int id) {
    log.info("Getting employee details for ID " + id);
    return empRepo.findOne(new Long(id));
  }

  public void addEmployee(Employee employee) {
    log.info("Adding Employee " + employee);
    empRepo.save(employee);
  }

  public void updateEmployee(Employee employee) {
    log.info("Updating Employee " + employee);
    empRepo.saveAndFlush(employee);
  }

  public void deleteEmployee(int id) {
    log.info("Deleting employee for ID " + id);
    empRepo.delete(new Long(id));
  }

}

Repository

Her er koden til EmployeeRepository-grænsefladen, som vi @Autowired i serviceklassen.

Denne grænseflade udvider en JpaRepository-grænseflade, der bruger generiske stoffer og har brug for en enhedsklasse markeret med @Entity med en egenskab markeret med @Id-annotering. For vores eksempel er enhedsklassen Employee og id er af typen Long.

JpaRepository bruger til gengæld PagingAndSortingRepository-grænsefladen, der giver metoderne save(), findAll(), delete(), som vi brugte med EmployeeRepository-forekomsten i serviceklassen.

package com.topjavatutorial.repo;

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

import com.topjavatutorial.entity.Employee;

public interface EmployeeRepository extends JpaRepository<Employee,Long> {

}

Spring Boot Application class

Hovedklassen er kommenteret med @SpringBootApplication. Dette vil blive autogenereret med Spring Boot-appen.

Vi har ændret det til at implementere CommandLineRunner-grænsefladen og tilsidesætte run()-metoden og tilføjet koden for at kalde EmployeeService-metoderne for at udføre CRUD-operationerne.

package com.topjavatutorial;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.topjavatutorial.entity.Employee;
import com.topjavatutorial.service.EmployeeService;

@SpringBootApplication
public class Application implements CommandLineRunner{

  private static final Logger log = LoggerFactory
      .getLogger(Application.class);
  
  @Autowired
  EmployeeService service;

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(String... arg0) throws Exception {
    service.addEmployee(new Employee("John", 23));
    service.addEmployee(new Employee("Jane", 24));
    
    
    service.getAllEmployees().forEach(
        emp -> log.info(emp.toString()));
    
    Employee temp = service.getEmployeeById(2);
    temp.setName("Janet");
    service.updateEmployee(temp);
    
    log.info("Getting All Employee Data after Update");
    service.getAllEmployees().forEach(
        emp -> log.info(emp.toString()));
    
    service.deleteEmployee(1);
    
    log.info("Getting All Employee Data after Delete");
    service.getAllEmployees().forEach(
        emp -> log.info(emp.toString()));
  }
}

Output:

Tomcat startede på port(e):8080 (http)

Tilføjelse af ansat medarbejder(Id :null, Navn :John, Alder :23)
Tilføjelse af medarbejdermedarbejder(Id :null, Navn :Jane, Alder :24)

inde i EmployeeService.getAllEmployees
Medarbejder(Id :1, Navn :John, Alder :23)
Medarbejder(Id :2, Navn :Jane, Alder :24)

Henter medarbejderoplysninger til ID 2
Opdatering af medarbejdermedarbejder(Id :2, navn :Janet, alder :24)
Henter alle medarbejderdata efter opdatering
inde i EmployeeService.getAllEmployees
Medarbejder( Id :1, Navn :John, Alder :23)
Medarbejder(Id :2, Navn :Janet, Alder :24)

Sletter medarbejder for ID 1
Henter alle medarbejderdata efter sletning
inde i EmployeeService.getAllEmployees
Medarbejder(Id :2, Navn :Janet, Alder :24)


Java tag