❗️JPA의 DTO와 Entity

이번 시간에는 제가 JPA를 사용하면서 Entity와 DTO의 적절히 사용했던 경험에 대해 알려드리려고 합니다.

보통 회원가입 기능을 만든다고하면, 회원에 관련된 데이터베이스 컬럼과, 회원가입 폼에서 사용하는 컬럼은 대부분 다를 것 입니다.

회원가입의 Entity가 있다고 가정해 보겠습니다. 회원의 관련된 Entity인 User 클래스는 다음과 같습니다.

public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(nullable = false)
    private String email;

    private String nickname;

    @JsonIgnore
    private String password;

    @Column(columnDefinition="bit(1) default 1")
    private boolean enabled;

    @Column(columnDefinition="bit(1) default 1")
    private boolean acceptOptionalBenefitAlerts;

    private String fcmToken;

    private boolean privateAccount;
}

그러나 회원가입을 진행할 때 클라이언트로부터 받는 데이터는 email과 nickname 그리고 password만 필요합니다. 이 3개의 데이터를 어떻게 받아 올 수 있을까요?

저는 주로 각 기능마다 필요로 하는 필드들을 모은 DTO 클래스를 만들어 받습니다.

예를 들어 회원가입 로직이 들어가있는 API의 형태는 다음과 같습니다.

@PostMapping("/join")
public UserJoinResponse joinUser(@RequestBody @Valid UserJoinRequest userJoinRequest) {
	return userService.joinUser(userJoinRequest);
}

UserJoinRequest의 구성은 다음과 같습니다.

public class UserJoinRequest {
    @NotBlank(message = "이메일을 다시 확인해주세요.")
    String email;

    @NotBlank(message = "비밀번호를 다시 확인해주세요.")
    String password;

    @NotBlank(message = "닉네임을 다시 확인해주세요.")
    String nickname;
}

그러나 Service 단에서, DAO로 데이터를 저장시키기 위해서 이 DTO를 Entity로 변환해주는 작업이 필요합니다.

public UserJoinResponse joinUser(UserJoinRequest userJoinRequest) {
  User user=userRepository.save(user); //??
}

이 작업은 어떤 식으로 진행하는 것이 좋을까요?

UserJoinRequest를 User Entity로 변환해주는 책임은 바로 UserJoinRequest에게 있습니다. 그렇기 때문에 UserJoinRequest가 User로 변환을 해주는 로직이 필요합니다.

public class UserJoinRequest {
    @NotBlank(message = "이메일을 다시 확인해주세요.")
    String email;

    @NotBlank(message = "비밀번호를 다시 확인해주세요.")
    String password;

    @NotBlank(message = "닉네임을 다시 확인해주세요.")
    String nickname;

    public User toEntity() {
        return User.builder()
                .email(email)
                .nickname(nickname)
                .password(password)
                .build();
    }
}

toEntity() 함수에서 User 객체를 만들때는 Builder 패턴을 이용했습니다.

서비스 단에서는 다음과 같이 사용합니다.

public UserJoinResponse joinUser(UserJoinRequest userJoinRequest) {
  User saveUser = userJoinRequest.toEntity();
  User user = userRepository.save(user);
}

정상적으로 User가 데이터베이스에 저장되었다면, 클라이언트에게 보내줄 데이터를 만들어 보겠습니다.

저는 예제로 클라이언트에게 유저의 email을 클라이언트에게 보내보겠습니다. 현재 서비스단의 joinUser() 함수의 리턴 값은 UserJoinResponse 이기 때문에 User를 UserJoinResponse로 변경해주는 작업이 필요합니다.

이 또한 이 변경의 책임 은 누구한테 있는지 고민한다면 User 에게 있을 것입니다. 그러므로 User 클래스 안에 UserJoinResponse 객체를 만들어 주는 함수가 있어야 합니다.

회원가입이 성공적으로 완료되면 클라이언트에게 email 값을 주는 UserJoinResponse 입니다.

public class UserJoinResponse {
    String email;
}

User의 함수는 다음과 같습니다.

public class User {
	...필드 생략
	
	public UserJoinResponse toUserJoinResponse() {
		 return User.UserJoinResponse()
                .email(email)
                .build();
	}
}

지금까지 제가 JPA를 사용하면서 주로 사용했던 내용을 작성했습니다.

저는 위와 같은 방법을 주로 사용하지만, 이렇게 클래스마다 Entity <-> DTO 변환 클래스를 작성하지 않아도, 자동으로 변환해주는 라이브러리가 있어서 소개해 드리려고 합니다.

😯 ModelMapper

ModelMapper 라이브러리를 사용하게 되면 간편하게 Entity <-> DTO 변환이 가능해 집니다.

public UserJoinResponse joinUser(UserJoinRequest userJoinRequest) {
  ModelMapper mm = new ModelMapper(); 
  User user = new User();
  mm.map(userJoinRequest, user);
  User user =	userRepository.save(user);
}

이런 방법도 있지만, 개인적으로 처음 설명해드렸던 방법을 추천합니다.

🧐 Entity vs DTO

이렇게 특정 필드만 받을 수 있게 DTO 클래스를 만들었습니다. 그러나 프로젝트가 커지게 되면 DTO 클래스는 계속 증가합니다.

그냥 Entity 클래스를 받아서 필요한 값만 추출해서 사용하면 될것인데, 왜 굳이 이렇게 DTO 클래스를 새로 만들어서 사용 할까요?

DTO 클래스를 사용하는 이유는 다음과 같습니다.

서비스 단은 데이터베이스와 독립적이어야 합니다. 데이터베이스의 변경사항이 있으면, Entity를 사용하는 서비스 단에도 변경이 일어날 수 있습니다.

또한 Entity 클래스를 DTO로 재사용 하는 일은 코드가 더러워질 수 있습니다. 클래스가 DTO로써 사용 될 때 사용하는 메소드와 Entity로써 사용 될 때 사용하는 메소드가 공존하게 됩니다. 이런 점에서 관심사 가 깔끔하게 분리되지 않고, 클래스의 결합력만 높이게 됩니다.

참고문서

https://stackoverflow.com/questions/5216633/jpa-entities-and-vs-dtos

https://auth0.com/blog/automatically-mapping-dto-to-entity-on-spring-boot-apis/

Hey guys in this post, we discuss Data JPA finder methods by multiple field names with examples.

Overview


JPA finder methods are the most powerful methods, we can create finder methods to select the records from the database without writing SQL queries. Behind the scenes, Data JPA will create SQL queries based on the finder method and execute the query for us.

To create finder methods in Data JPA, we need to follow a certain naming convention. To create finder methods for the entity class field name, we need to create a method starting with findBy followed by field name. If we want to create finder methods for multiple field names then we need to use logical operators such as AND, OR between the field names. Consider the following Employee entity class which has 2 fields name and location

public class Employee {
	
	private String name;
	
	private String location;
	
	//setters and getters
}

To query the database that should match both name and location then we need to create a method like this –

findByNameAndLocation(String name, String location)

To query the database that should match any one of the columns then we need to create a method like this –

findByNameOrLocation(String name, String location)

Behind the scenes, Data JPA will create a SQL query like this –

SELECT * FROM employee WHERE name="employee name" AND location="location name";
SELECT * FROM employee WHERE name="employee name" OR location="location name";

As you can see, it’s so much easy to select the records with the help of finder methods. That’s the beauty of Data JPA.

NOTE: You can select any number of fields separated by logical operators.

Watch the video


 

Complete example


Let’s create a step-by-step spring boot project and create different finder methods for various fields.

Create database and insert sample data


Open MySQL workbench and execute the following commands

CREATE DATABASE mydb;

USE mydb;

CREATE TABLE tbl_laptops(
    id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    description VARCHAR(255) NOT NULL,
    brand VARCHAR(255) NOT NULL,
    price DOUBLE(10, 2) NOT NULL
);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("Dell Inspiron", "dell company laptop", "Dell", 60000.00);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("Dell XPS", "dell company laptop", "Dell", 70000.00);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("Macbook Air", "apple company laptop", "Apple", 85000.00);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("Macbook Pro", "apple company laptop", "Apple", 160000.00);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("HP", "hp company laptop", "HP", 50000.00);

INSERT INTO tbl_laptops(name, description, brand, price)
VALUES("Lenovo", "lenovo company laptop", "Lenovo", 50000.00);

SELECT * FROM tbl_laptops;

We have created a table tbl_laptops that contains 5 fields. We have inserted the sample data as well.

Create spring boot project


There are many different ways to create a spring boot application, you can follow the below articles to create one –

>> Create spring boot application using Spring initializer
>> Create spring boot application in Spring tool suite [STS]
>> Create spring boot application in IntelliJ IDEA

Add maven dependencies


Open pom.xml and add the following dependencies –

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.4</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>in.bushansirgur</groupId>
	<artifactId>findbyfieldname</artifactId>
	<version>v1</version>
	<name>findbyfieldname</name>
	<description>Spring boot data jpa find by field name</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

spring-boot-starter-web dependency for building web applications using Spring MVC. It uses the tomcat as the default embedded container.




spring-boot-devtools dependency for automatic reloads or live reload of applications. spring-boot-starter-data-jpa dependency is a starter for using Spring Data JPA with Hibernate. lombok dependency is a java library that will reduce the boilerplate code that we usually write inside every entity class like setters, getters, and toString()

Create an entity class


Create Laptop.java inside the in.bushansirgur.springboot.entity package and add the following content

package in.bushansirgur.springboot.entity;

import java.math.BigDecimal;

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

import lombok.Data;

@Entity
@Data
@Table(name="tbl_laptops")
public class Laptop {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Long id;
	
	private String name;
	
	private String description;
	
	private String brand;
	
	private BigDecimal price;
}

We have added @Data annotation which is a Lombok annotation, that will automatically create setters, getters, toString(), and equals() for us.

@Entity is a mandatory annotation that indicates that this class is a JPA entity and is mapped with a database table.

@Table annotation is an optional annotation that contains the table info like table name.




@Id annotation is a mandatory annotation that marks a field as the primary key

Create a Repository


Create an interface LaptopRepository.java inside the in.bushansirgur.springboot.repos package and add the following content

package in.bushansirgur.springboot.repos;

import java.math.BigDecimal;
import java.util.List;

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

import in.bushansirgur.springboot.entity.Laptop;

@Repository
public interface LaptopRepository extends JpaRepository<Laptop, Long> {
	
	List<Laptop> findByNameAndBrand(String name, String brand);
	
	List<Laptop> findByBrandAndPrice(String brand, BigDecimal Price);
	
	List<Laptop> findByNameOrBrandOrPrice(String name, String brand, BigDecimal price);
}

@Repository annotates classes at the persistence layer, which will act as a database repository. We have extended this interface with JPARepository interface which will provide built-in methods to interact with the database also we can define finder methods. We have defined 3 finder methods findByNameAndBrand(), findByBrandAndPrice() and findByNameOrBrandOrPrice() which will return the List<Laptops>

Create a Rest controller


Create LaptopController.java inside the in.bushansirgur.springboot.controller package and add the following content

package in.bushansirgur.springboot.controller;

import java.math.BigDecimal;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import in.bushansirgur.springboot.entity.Laptop;
import in.bushansirgur.springboot.repos.LaptopRepository;

@RestController
public class LaptopController {
	
	@Autowired
	LaptopRepository lRepo;
	
	@GetMapping("/laptops/nameandbrand")
	public ResponseEntity<List<Laptop>> getLaptopsByNameAndBrand(@RequestParam String name, 
				@RequestParam String brand) {
		return new ResponseEntity<List<Laptop>>(lRepo.findByNameAndBrand(name, brand), HttpStatus.OK);
	}
	
	@GetMapping("/laptops/brandandprice")
	public ResponseEntity<List<Laptop>> getLaptopsByBrandAndPrice(@RequestParam String brand, 
				@RequestParam BigDecimal price) {
		return new ResponseEntity<List<Laptop>>(lRepo.findByBrandAndPrice(brand, price), HttpStatus.OK);
	}
	
	@GetMapping("/laptops/nameorbrandorprice")
	public ResponseEntity<List<Laptop>> getLaptopsByNameOrBrandOrPrice(@RequestParam String name, 
				@RequestParam String brand,	
				@RequestParam BigDecimal price) {
		return new ResponseEntity<List<Laptop>>(lRepo.findByNameOrBrandOrPrice(name, brand, price), HttpStatus.OK);
	}
}

We have auto wired the LaptopRepository using @Autowired annotation. We have created 3 handler methods, getLaptopsByNameAndBrand(), getLaptopsByBrandAndPrice() and getLaptopsByNameOrBrandOrPrice() which will call the repository methods findByNameAndBrand(), findByBrandAndPrice() and findByNameOrBrandOrPrice() respectively.

Run the app


Run the application using the below maven command –

mvn spring-boot:run

Open the browser and enter the following URL –

  • http://localhost:8080/laptops/nameandbrand?name=dell inspiron&brand=dell
[
    {
        "id": 1,
        "name": "Dell Inspiron",
        "brand": "Dell",
        "description": "dell company laptop",
        "price": 60000.0
    }
]
  • http://localhost:8080/laptops/brandandprice?brand=hp&price=50000.00
[
    {
        "id": 5,
        "name": "HP",
        "brand": "HP",
        "description": "hp company laptop",
        "price": 50000.0
    }
]
  • http://localhost:8080/laptops/nameorbrandorprice?name=acer&brand=apple&price=90000.00
[
    {
        "id": 3,
        "name": "Macbook Air",
        "brand": "Apple",
        "description": "apple company laptop",
        "price": 85000.0
    },
    {
        "id": 4,
        "name": "Macbook Pro",
        "brand": "Apple",
        "description": "apple company laptop",
        "price": 160000.0
    }
]

References


+ Recent posts