코드로 배우는 스프링 부트 웹 프로젝트 02 : Maria DB와 Spring Data JPA

1. 프로젝트 생성

MariaDB아니고 mysql임

필요한 의존성을 선택하고 프로젝트를 생성했다.

MySQL(MariaDB) 드라이버와 함께 Lombok, Spring Boot DevTools, Spring Web, Spring Data JPA를 추가했다.

2. MySQL 설정

2.1 스키마 생성

먼저 MySQL Workbench를 사용하여 새로운 스키마를 생성했다.

스키마 이름은 bootex로 지정했다.

스키마를 생성한 후, 해당 스키마에 대한 사용자 권한을 설정했다.

사용자 testuser에게 bootex 스키마에 대한 모든 권한을 부여했다.

2.2 사용자 권한 설정

이 설정을 통해 testuser가 bootex 스키마에 접근하고 데이터를 조작할 수 있는 권한을 부여했다.

2.3 연결 설정

MariaDB Workbench에서 새로운 연결을 설정했다.

호스트는 127.0.0.1, 포트는 3306, 사용자 이름, 비밀번호를 입력하고, 기본 스키마를 bootex로 설정했다.

연결을 테스트하여 성공적으로 연결되는지 확인했다.

3. Spring Boot 애플리케이션 설정

3.1 데이터베이스 설정

application.properties 파일에 MariaDB와의 연결 설정을 추가했다.

spring.application.name=ex2
server.port=8090
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/bootex
spring.datasource.username=testuser
spring.datasource.password=test1234

---

데이터베이스 분리 이유

1. 성능 향상
   • 데이터베이스를 분리하면 각 스키마가 독립적으로 데이터베이스와 상호 작용할 수 있어, 성능이 향상된다.
   • 특정 스키마의 작업이 다른 스키마의 성능에 영향을 주지 않게 된다.
2. 보안 강화
   • 데이터베이스 분리를 통해 각 스키마에 대한 접근 권한을 제한할 수 있다.
   • 민감한 데이터에 대한 접근을 제한하여 보안을 강화할 수 있다.
3. 관리 용이성
   • 각 스키마가 독립적으로 데이터베이스를 관리할 수 있어, 유지보수가 용이하다.
   • 데이터베이스의 구조 변경이나 백업, 복구 작업이 더 쉽게 이루어진다.
4. 데이터 무결성 유지
   • 데이터베이스를 분리하면 각 스키마가 독립적으로 데이터 무결성을 유지할 수 있다.
   • 특정 스키마의 데이터 손상이 다른 스키마에 영향을 주지 않게 된다.
5. 스케일링 용이
   • 데이터베이스를 분리하면 필요한 스키마만 독립적으로 스케일링할 수 있다.
   • 전체 시스템의 확장성이 향상된다.

이 그림은 데이터베이스를 분리하여 애플리케이션의 각 모듈이 독립적으로 데이터를 관리하고 접근할 수 있도록 하는 과정을 설명하고 있다. 이를 통해 성능 향상, 보안 강화, 관리 용이성, 데이터 무결성 유지, 스케일링 용이성 등의 이점을 얻을 수 있다. 데이터베이스 분리는 복잡한 애플리케이션의 효율적인 데이터 관리를 위한 중요한 설계 전략이다.

---

이 그림은 Java 애플리케이션에서 데이터베이스와 상호 작용하는 과정을 도식화한 것이다.

1. Java App:
   • 이 부분은 Java 애플리케이션을 나타낸다. 애플리케이션은 데이터베이스와 통신하여 데이터를 읽고 쓸 수 있다.
2. DB (Database):
   • 데이터베이스는 애플리케이션이 데이터를 저장하고 조회하는 장소다. 그림에서 화살표로 표시된 통신은 Java 애플리케이션과 데이터베이스 간의 데이터 흐름을 나타낸다.
3. DAO (Data Access Object):
   • 그림의 중앙에 위치한 박스는 DAO를 나타낸다. DAO는 데이터베이스에 접근하기 위한 인터페이스를 제공하며, Java 애플리케이션과 데이터베이스 간의 통신을 추상화한다.
   • 이 그림에서는 파란색 화살표로 표시된 것이 DAO가 데이터베이스와 상호 작용하는 방식을 나타낸다.
4. VO (Value Object):
   • 그림의 왼쪽 하단에 위치한 "MemberVO"는 Value Object를 나타낸다. VO는 데이터베이스에서 조회한 데이터를 담는 객체다.
   • Java 애플리케이션은 DAO를 통해 데이터베이스와 통신하고, VO를 사용하여 데이터를 주고받는다.
5. Persist Context:
   • 그림의 중앙에 있는 부분은 Persistence Context를 나타낸다. 이는 JPA와 같은 ORM 프레임워크에서 데이터베이스 엔티티의 상태를 관리하는 컨텍스트다.
   • Persistence Context는 애플리케이션이 엔티티를 데이터베이스에 저장하거나 조회할 때 그 상태를 관리한다.

Persistence Context란?

Persistence Context는 JPA(Java Persistence API)에서 매우 중요한 개념으로, 엔티티 매니저(Entity Manager)에 의해 관리되는 엔티티 객체들의 집합을 말한다.

Persistence Context는 데이터베이스와 상호작용하는 과정에서 엔티티 객체들의 상태를 관리하고 동기화하는 역할을 한다.

주요 기능

1. 엔티티 상태 관리
   • Persistence Context는 엔티티 객체의 생명주기(생성, 읽기, 업데이트, 삭제)를 관리한다.
   • 엔티티 객체가 Persistence Context에 포함되면 "관리됨(managed)" 상태가 된다.
2. 1차 캐시 역할
   • Persistence Context는 1차 캐시로 작동하여 동일한 트랜잭션 내에서 동일한 엔티티에 대한 데이터베이스 접근을 최소화한다.
   • 한 번 로드된 엔티티 객체는 Persistence Context 내에서 캐시되므로, 다시 조회할 때 데이터베이스에 접근하지 않고 캐시된 객체를 반환한다.
3. 변경 감지(Dirty Checking)
   • 엔티티 객체의 상태 변화(필드 값 변경)를 자동으로 감지한다.
   • 트랜잭션이 종료되기 전에 Persistence Context는 변경된 엔티티 객체를 데이터베이스와 동기화한다.
4. 지연 로딩(Lazy Loading)
   • Persistence Context는 필요한 시점에만 데이터베이스 조회를 수행하는 지연 로딩을 지원한다.
   • 이는 성능 최적화에 도움을 준다.

6. Flow of Data:

• 화살표는 데이터의 흐름을 나타낸다. Java 애플리케이션이 DAO를 통해 데이터베이스와 상호 작용하고, 이 과정에서 VO를 사용하여 데이터를 주고받는 구조다.
• 데이터는 Java 애플리케이션에서 DAO를 통해 Persistence Context로, 다시 데이터베이스로 이동한다. 데이터베이스에서 데이터를 조회하면 반대 방향으로 흐른다.

결론

이 그림은 Java 애플리케이션과 데이터베이스 간의 데이터 흐름을 시각적으로 설명한 것이다.

DAO를 통해 데이터베이스와 통신하고, VO를 사용하여 데이터를 전달하며, Persistence Context를 통해 엔티티의 상태를 관리하는 과정을 이해할 수 있다.

이러한 구조를 통해 애플리케이션은 효율적이고 일관성 있게 데이터베이스와 상호 작용할 수 있다.

---

Spring Boot와 JPA를 이용한 데이터베이스 연동

이번 포스팅에서는 Spring Boot와 JPA를 이용하여 데이터베이스와의 연동을 구현하는 방법을 설명하겠다.

특히 ORM과 JPA, 그리고 Hibernate에 대해 알아보고, 예제 코드를 통해 데이터베이스에 테이블이 생성되는 과정을 확인하겠다.

ORM과 JPA

ORM이란?

ORM(Object-Relational Mapping)은 객체 지향 프로그래밍 언어를 사용하여 관계형 데이터베이스를 조작하는 기술이다.

ORM을 사용하면 데이터베이스 테이블을 객체로 매핑하여, SQL을 직접 작성하지 않고도 데이터베이스와 상호작용할 수 있다.

이는 코드의 가독성을 높이고 유지보수를 용이하게 한다.

JPA란?

JPA(Java Persistence API)는 자바에서 ORM을 구현하기 위한 표준 인터페이스를 제공하는 스펙이다.

JPA를 사용하면 애플리케이션의 데이터 계층을 객체 지향적으로 설계할 수 있다.

JPA는 데이터베이스와의 상호작용을 추상화하여, 데이터베이스 독립적인 애플리케이션을 개발할 수 있게 한다.

Hibernate라는 구현체

Hibernate는 JPA의 가장 유명한 구현체 중 하나이다.

Hibernate는 JPA 표준을 구현하며, 추가적으로 다양한 기능을 제공한다.

이를 통해 개발자는 데이터베이스와의 복잡한 상호작용을 간단하고 직관적인 코드로 작성할 수 있다.

 

애플리케이션 실행 및 테이블 생성 확인

Spring Boot 애플리케이션을 실행하면 JPA와 Hibernate가 데이터베이스에 연결되어, tbl_memo 테이블이 자동으로 생성된다. 이를 MySQL Workbench를 통해 확인할 수 있다.

---

Spring Data JPA를 위한 Spring Boot 설정 및 CRUD 연습

예제 코드: Memo 엔티티 클래스

Spring Boot와 JPA를 이용하여 데이터베이스에 테이블을 생성하는 예제를 살펴보자

package org.zerock.ex2.entity;

import jakarta.persistence.*;
import lombok.*;

@Entity
@Table(name="tbl_memo")
@ToString
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class Memo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long mno;

    @Column(length = 200,nullable = false)
    private String memoText;
}

코드 설명

• @Entity: Memo 클래스가 JPA 엔티티임을 선언한다.
• @Table(name = "tbl_memo"): Memo 엔티티가 데이터베이스의 tbl_memo 테이블과 매핑됨을 지정한다.
• @Id: mno 필드가 엔티티의 기본 키임을 지정한다.
• @GeneratedValue(strategy = GenerationType.IDENTITY): mno 필드의 값이 데이터베이스에 의해 자동으로 생성됨을 지정한다.
• @Column(length = 200, nullable = false): memoText 필드가 길이 200의 문자열 컬럼이며, null 값을 허용하지 않음을 지정한다.
• @ToString, @Getter, @Builder, @AllArgsConstructor, @NoArgsConstructor: Lombok 애노테이션을 사용하여 자동으로 메서드를 생성한다.

이렇게 설정한 후 애플리케이션을 실행하면, JPA와 Hibernate가 데이터베이스와 상호작용하여 tbl_memo 테이블이 생성되고 Memo 엔티티 클래스의 인스턴스를 테이블의 행(row)으로 관리할 수 있게 된다.

엔티티(Entity)란?

엔티티(Entity)는 데이터베이스의 테이블에 매핑되는 클래스이다.

엔티티 클래스는 데이터베이스의 한 행(row)에 해당하는 데이터를 객체 형태로 표현한다.

엔티티를 사용하면 객체 지향 프로그래밍 언어에서 관계형 데이터베이스의 데이터를 쉽게 조작할 수 있다.

JPA(Java Persistence API)는 엔티티를 통해 데이터베이스와 상호작용한다.

엔티티의 특징

1. 데이터베이스 테이블과 매핑:
   • 엔티티 클래스는 데이터베이스의 테이블과 직접적으로 매핑된다.
   • 엔티티 클래스의 각 필드는 데이터베이스 테이블의 컬럼에 매핑된다.
2. 주요 애노테이션:
   • @Entity: 클래스가 JPA 엔티티임을 나타낸다.
   • @Table: 엔티티와 매핑할 테이블의 정보를 제공한다.
   • @Id: 엔티티의 기본 키(primary key)를 나타낸다.
   • @GeneratedValue: 기본 키의 값을 자동으로 생성하도록 설정한다.
   • @Column: 필드를 테이블의 컬럼과 매핑하고, 컬럼의 속성을 정의한다.
3. 객체 지향적 데이터 접근:
   • 엔티티를 사용하면 객체 지향 방식으로 데이터를 접근하고 조작할 수 있다.
   • SQL 쿼리를 직접 작성할 필요 없이, JPA를 통해 데이터베이스와 상호작용할 수 있다. 

 

JPA Repository 인터페이스

JPA Repository 인터페이스를 사용하여 기본적인 CRUD 메서드를 구현하고, 추가적인 쿼리 메서드를 정의할 수 있다.

MemoRepository 인터페이스

package org.zerock.ex2.repository;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.zerock.ex2.entity.Memo;

import java.util.List;

public interface MemoRepository extends JpaRepository<Memo, Long> {
    // memoText로 검색
    Memo findByMemoText(String memoText);

    // like 검색
    List<Memo> findByMemoTextContaining(String memoText);

    // 1 또는 2가 들어있는
    List<Memo> findByMemoTextContainingOrMemoTextContaining(String memoText1, String memoText2);

    // 범위 내에서 페이징 처리된 결과를 조회
    Page<Memo> findByMnoBetween(Long from, Long to, Pageable pageable);

    // 특정 mno 값 이하의 엔티티 삭제
    void deleteByMnoLessThan(Long mno);
}

MemoRepository 인터페이스는 JpaRepository를 상속받아 기본적인 CRUD 기능을 제공하며, 다음과 같은 추가적인 쿼리 메서드를 정의하여 데이터 조회와 삭제 기능을 구현한다:

1. Memo findByMemoText(String memoText):
   • memoText 필드의 값이 주어진 문자열과 정확히 일치하는 Memo 엔티티를 조회한다.
2. List findByMemoTextContaining(String memoText):
   • memoText 필드의 값이 주어진 문자열을 포함하는 모든 Memo 엔티티를 조회한다.
3. List findByMemoTextContainingOrMemoTextContaining(String memoText1, String memoText2):
   • memoText 필드의 값이 주어진 두 문자열 중 하나라도 포함하는 모든 Memo 엔티티를 조회한다.
4. Page findByMnoBetween(Long from, Long to, Pageable pageable):
   • mno 필드의 값이 주어진 범위 내에 있는 Memo 엔티티를 페이징 처리하여 조회한다.
5. void deleteByMnoLessThan(Long mno):
   • mno 필드의 값이 주어진 값보다 작은 모든 Memo 엔티티를 삭제한다

테스트 코드로 CRUD 연습

Spring Boot의 테스트 기능을 사용하여 CRUD 연습을 해보겠다.

@Test란?

@Test 애노테이션은 JUnit 프레임워크에서 테스트 메서드를 지정하는 데 사용된다. JUnit은 자바 기반의 단위 테스트 프레임워크로, 개발자가 작성한 코드의 동작을 검증하고 유지보수성을 높이는 데 도움을 준다. @Test 애노테이션을 사용하면 해당 메서드가 테스트 실행 시 자동으로 호출된다.

주요 기능

1. 테스트 메서드 지정:
   • @Test 애노테이션을 사용하여 JUnit에게 해당 메서드가 테스트 목적으로 작성되었음을 알린다.
   • JUnit은 @Test 애노테이션이 있는 모든 메서드를 찾아 실행한다.
2. 자동 실행:
   • 테스트 메서드는 특정 조건을 만족하는지 여부를 확인하기 위해 작성되며, JUnit이 자동으로 실행하여 결과를 검증한다.
   • 메서드 이름은 자유롭게 정할 수 있지만, 일반적으로 테스트하려는 기능이나 시나리오를 나타내도록 명명한다.
3. 예외 처리 검증:
   • @Test 애노테이션은 예상되는 예외를 지정할 수 있다. 이를 통해 특정 조건에서 예외가 발생하는지 확인할 수 있다.
   • expected 속성을 사용하여 예상되는 예외 타입을 지정한다.

MemoRepositoryTests 클래스

각 테스트 메서드의 기능 설명

위 코드는 Spring Boot와 JPA를 이용한 다양한 CRUD 및 페이징, 정렬 기능을 테스트하는 클래스이다.

1. testClass()

@Test
public void testClass() {
    System.out.println(memoRepository.getClass().getName());
}

• 기능: memoRepository 객체의 실제 클래스 이름을 출력
• 목적: memoRepository가 Spring Data JPA에 의해 올바르게 주입되었는지 확인

2. testInsertDummies()

@Test
public void testInsertDummies() {
    IntStream.rangeClosed(1, 100).forEach(i -> {
        Memo memo = Memo.builder().memoText("Sample..." + i).build();
        memoRepository.save(memo);
    });
}

• 기능: 1부터 100까지의 숫자를 포함하는 Sample... 문자열을 가진 Memo 객체 100개를 데이터베이스에 삽입
• 목적: 테스트 데이터로 사용할 Memo 엔티티 객체를 대량으로 삽입

3. testSelect()

@Test
public void testSelect() {
    Long mno = 100L;
    Optional<Memo> result = memoRepository.findById(mno);
    System.out.println("------------------");
    if (result.isPresent()) {
        Memo memo = result.get();
        System.out.println(memo);
    }
}

• 기능: 기본 키(mno)가 100인 Memo 객체를 데이터베이스에서 조회
• 목적: 특정 Memo 객체가 데이터베이스에 존재하는지 확인하고, 존재한다면 해당 객체를 출력

 

자동 실행되는 SQL과 데이터베이스 결과

테스트 코드를 실행하면 다음과 같은 SQL 쿼리가 자동으로 실행된다.

자동 실행되는 SQL 일부와 데이터베이스의 결과

select * from bootex.tbl_memo;

위와 같은 방법으로 Spring Data JPA를 사용하여 간단한 CRUD 기능을 구현하고 테스트할 수 있다.

이를 통해 데이터베이스와의 연동을 효율적으로 관리하고 필요한 데이터를 쉽게 조작할 수 있다.

4. testUpdate()

@Test
public void testUpdate() {
    Memo memo = Memo.builder().mno(100L).memoText("Update Test").build();
    System.out.println(memoRepository.save(memo));
}

• 기능: 기본 키가 100인 Memo 객체의 memoText를 "Update Test"로 업데이트
• 목적: 특정 Memo 객체의 필드 값을 업데이트하고, 업데이트된 객체를 출력

5. testDelete()

@Test
public void testDelete() {
    Long mno = 100L;
    memoRepository.deleteById(mno);
}

• 기능: 기본 키가 100인 Memo 객체를 데이터베이스에서 삭제
• 목적: 특정 Memo 객체를 데이터베이스에서 삭제

메서드 이름으로 SQL 처리

Spring Data JPA는 메서드 이름을 기반으로 SQL 쿼리를 생성하는 강력한 기능을 제공한다.

메서드 이름에 키워드를 포함하여 다양한 쿼리를 작성할 수 있다.

예를 들어, findByMemoText 메서드는 memoText 필드를 기준으로 데이터를 검색하는 쿼리를 생성한다.

6. testSearch()

@Test
public void testSearch() {
    Memo memo = memoRepository.findByMemoText("Sample...99");
    System.out.println(memo);
}

• 기능: memoText가 "Sample...99"인 Memo 객체를 데이터베이스에서 조회
• 목적: 특정 텍스트로 Memo 객체를 검색하고, 검색된 객체를 출력

7. testSearch2()

@Test
public void testSearch2() {
    memoRepository.findByMemoTextContaining("1").stream().forEach(e -> {
        System.out.println(e);
    });
}

• 기능: memoText에 "1"이 포함된 모든 Memo 객체를 데이터베이스에서 조회
• 목적: 특정 문자열을 포함하는 Memo 객체를 검색하고, 검색된 객체들을 출력

8. testPageDefault()

Spring Data JPA에서 페이징 처리는 0부터 시작한다.

페이징 처리를 위해 Pageable 인터페이스와 PageRequest 클래스를 사용한다.

PageRequest.of(int page, int size) 메서드를 통해 페이지 번호와 페이지 크기를 설정할 수 있다.

예제에서는 페이지 번호 0과 크기 10으로 설정하여 데이터를 조회한다.

@Test
public void testPageDefault() {
    Pageable pageable = PageRequest.of(0, 10);
    Page<Memo> result = memoRepository.findAll(pageable);
    System.out.println(result);
    System.out.println("-------------------");
    System.out.println("Total Pages: " + result.getTotalPages());
    System.out.println("Total Elements: " + result.getTotalElements());
    System.out.println("Page Number: " + result.getNumber());
    System.out.println("Page Size: " + result.getSize());
    System.out.println("hasPrevious: " + result.hasPrevious());
    System.out.println("hasNext: " + result.hasNext());
    System.out.println("first page: " + result.isFirst());
    System.out.println("-------------------");
    for (Memo memo : result.getContent()) {
        System.out.println(memo);
    }
}

• 기능: 페이지 번호가 0이고, 페이지 크기가 10인 페이지를 조회한다. 조회된 페이지의 메타데이터와 콘텐츠를 출력
• 목적: 기본 페이징 기능을 테스트하고, 페이지 관련 정보를 출력

9. testSort()

정렬 기능을 추가하여 페이징 처리할 수 있다.

Sort 클래스를 사용하여 정렬 기준을 설정하고, PageRequest.of(int page, int size, Sort sort) 메서드를 통해 정렬 정보를 포함한 페이지 요청을 생성할 수 있다.

@Test
public void testSort() {
    Sort sort1 = Sort.by("mno").descending();
    Pageable pageable = PageRequest.of(0, 10, sort1);
    Page<Memo> result = memoRepository.findAll(pageable);
    result.get().forEach(memo -> {
        System.out.println(memo);
    });
}

• 기능: mno 필드를 기준으로 내림차순 정렬하여 페이지 번호가 0이고, 페이지 크기가 10인 페이지를 조회한다. 조회된 페이지의 콘텐츠를 출력
• 목적: 정렬된 페이징 기능을 테스트하고, 정렬된 결과를 출력

10. testQueryMethodWithPageable()

정렬 기능을 추가하여 페이징 처리할 수 있다.

    @Test
    public void testQueryMethodWithPageable() {
        Pageable pageable = PageRequest.of(1, 10, Sort.by("mno").descending());
        Page<Memo> result = memoRepository.findByMnoBetween(10L, 50L, pageable);
        result.get().forEach(m-> System.out.println(m));
    }

메서드 설명: testQueryMethodWithPageable()

이 메서드는 Spring Data JPA의 페이징과 정렬 기능을 사용하여 특정 범위의 Memo 엔티티를 조회하고, 결과를 출력하는 테스트 메서드이다.

코드 설명

1. 페이징 설정:
   • PageRequest.of(int page, int size, Sort sort)를 사용하여 페이징 정보를 생성한다.
   • page는 페이지 번호를 나타내며, 0부터 시작한다. 여기서는 1로 설정되어 두 번째 페이지를 나타낸다.
   • size는 한 페이지당 조회할 데이터 개수를 나타낸다. 여기서는 10으로 설정되어 한 페이지에 10개의 데이터를 조회한다.
   • Sort.by("mno").descending()는 mno 필드를 기준으로 내림차순 정렬을 설정한다.
2. Pageable pageable = PageRequest.of(1, 10, Sort.by("mno").descending());
3. 데이터 조회:
   • findByMnoBetween(Long from, Long to, Pageable pageable) 메서드를 호출하여 mno 필드의 값이 10과 50 사이에 있는 Memo 엔티티를 페이징 처리하여 조회한다.
   • pageable 파라미터를 통해 두 번째 페이지에 해당하는 데이터를 가져오며, 한 페이지당 최대 10개의 데이터를 내림차순으로 정렬하여 조회한다.
   • 반환값은 Page<Memo> 타입으로, 페이징 처리된 결과를 포함한다.
4. Page<Memo> result = memoRepository.findByMnoBetween(10L, 50L, pageable);
5. 결과 출력:
   • result.get() 메서드를 사용하여 페이징된 결과 리스트를 가져온다.
   • forEach 메서드를 사용하여 각 Memo 엔티티를 출력한다.
6. result.get().forEach(m-> System.out.println(m));

요약

testQueryMethodWithPageable() 메서드는 Spring Data JPA의 페이징과 정렬 기능을 활용하여 특정 범위 (mno가 10에서 50 사이)의 데이터를 조회하고, 두 번째 페이지(페이지 크기: 10)의 데이터를 mno 기준 내림차순으로 정렬하여 출력한다. 이를 통해 데이터의 페이징 처리 및 정렬 기능을 테스트할 수 있다.

결론

이 클래스는 Spring Data JPA를 사용하여 기본적인 CRUD 작업, 검색, 페이징, 정렬 등의 기능을 테스트하는 방법을 보여준다.

각각의 테스트 메서드는 데이터베이스와 상호작용하여 특정 작업을 수행하고, 결과를 출력한다. 이를 통해 JPA의 다양한 기능을 손쉽게 테스트하고 활용할 수 있다.

---