[SpringBoot] JPA

◈ JPA 란?

JPA(Java Persistence API)는 자바(Java) 애플리케이션에서 관계형 데이터베이스를 사용할 수 있도록 지원하는 표준 API입니다. JPA는 객체 지향 프로그래밍과 관계형 데이터베이스 사이의 불일치를 해결하기 위해 설계된 ORM(Object-Relational Mapping) 기술의 한 종류입니다.

JPA의 주요 개념

1. ORM(Object-Relational Mapping): 객체 지향 프로그래밍 언어인 자바와 관계형 데이터베이스의 테이블을 매핑하는 기술입니다. 이를 통해 객체와 데이터베이스 간의 데이터 변환을 자동으로 처리할 수 있습니다.
2. Entity: JPA에서 데이터베이스 테이블과 매핑되는 자바 클래스입니다. 이 클래스는 애플리케이션에서 데이터베이스 테이블의 행을 표현하며, 각 필드는 테이블의 컬럼에 매핑됩니다.
3. Persistence Context: 엔티티의 생명 주기를 관리하는 환경입니다. Persistence Context는 엔티티를 영속성 상태로 유지하고, 변경이 발생하면 데이터베이스와 동기화하는 역할을 합니다.
4. EntityManager: 엔티티를 생성, 수정, 삭제, 조회 등의 작업을 수행하는 JPA의 핵심 인터페이스입니다. 애플리케이션에서 데이터베이스 작업을 제어하고, Persistence Context를 관리합니다.
5. JPQL(Java Persistence Query Language): JPA에서 제공하는 SQL과 유사한 객체 지향 쿼리 언어입니다. 엔티티 객체를 대상으로 하는 쿼리를 작성할 수 있으며, SQL에 비해 더 객체 지향적이고 데이터베이스 독립적입니다.

JPA의 장점

• 데이터베이스 독립성: JPA를 사용하면 데이터베이스 종속적이지 않은 코드 작성이 가능하여, 특정 데이터베이스에 종속되지 않고 여러 데이터베이스 간의 전환이 쉬워집니다.
• 생산성 향상: SQL을 직접 작성하지 않고, 객체 지향적인 방법으로 데이터베이스 작업을 수행할 수 있어 개발 생산성이 향상됩니다.
• 유지보수 용이성: 객체 지향적인 모델을 사용하여 비즈니스 로직과 데이터 접근 로직을 분리할 수 있으므로 코드의 가독성과 유지보수성이 개선됩니다.
• 성능 최적화: 1차 캐시, 지연 로딩(Lazy Loading) 등 다양한 성능 최적화 기법을 지원합니다.

JPA와 관련된 기술

JPA는 인터페이스 기반의 표준 API로, 이를 구현한 여러 프레임워크가 존재합니다. 가장 대표적인 구현체로는 Hibernate, EclipseLink, DataNucleus 등이 있으며, Spring Data JPA는 스프링 프레임워크와 JPA를 통합해 보다 간편하게 JPA를 사용할 수 있도록 도와줍니다.

결론

JPA는 자바 애플리케이션에서 관계형 데이터베이스와의 상호작용을 단순화하고, 데이터베이스 독립적인 방식으로 데이터를 처리할 수 있게 도와주는 강력한 ORM 기술입니다. 이를 통해 객체 지향적인 방법으로 데이터베이스를 다룰 수 있으며, 개발 생산성과 유지보수성을 크게 향상시킬 수 있습니다.

---

 

 

 

---

 

package com.example.jpa.memo.repository;

import com.example.jpa.entity.MemberMemoDTO;
import com.example.jpa.entity.Memo;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

public interface MemoRepository extends JpaRepository<Memo, Long>, //엔티티타입, ID에 대한 타입
                                        MemoCustomRepository, //커스텀레포지토리
                                        QuerydslPredicateExecutor<Memo> { //쿼리DSL에서 제공되는 몇몇 함수들을 제공해주는 인터페이스
    
    //JpaRepository로 부터, 몇개의 추상메서드를 자동으로 상속받게 됩니다.

    //쿼리메서드
    Memo findByWriterAndText(String writer, String text);

    List<Memo> findByMnoLessThan(Long mno);

//    SELECT * FROM MEMO WHERE MNO = 11;
    Memo findByMno(Long mno);
//    SELECT * FROM MEMO WHERE MNO BETWEEN 10 AND 20;
    List<Memo> findByMnoBetween(Long start, Long end);
//    SELECT * FROM MEMO WHERE WRITER LIKE '%10%';
    List<Memo> findByWriterLike(String str);
//    SELECT * FROM MEMO WHERE WRITER = 'example1' ORDER BY WRITER DESC;
    List<Memo> findByWriterOrderByWriterDesc(String writer);
//    SELECT * FROM MEMO WHERE MNO IN (10,20,30,40,50);
    List<Memo> findByMnoIn(List<Long> list);
//쿼리메서드의 마지막 매개변수에 Pageable을 주면, 페이징처리합니다.
    List<Memo> findByMnoLessThanEqual(Long mno, Pageable pageable);

    //////////////////////////////////////////////////////////////
    //JPQL - SQL과 비슷하나, 엔티티를 사용해서 sql문을 작성
    //select, update, delete는 제공되는데, insert는 제공하지 않습니다.
    //1. 테이블명이 아니라 엔티티가 사용됨
    //2. 속성(필드)은 대소문자를 전부 구분
    //3. 별칭은 필수
    //4. SQL키워드 구분 x
    @Query("select m from Memo m order by m.mno desc")
    List<Memo> getListDesc(); //메서드명 자유
    
    //JPQL파라미터 전달 @Param(이름), :이름
    @Query("select m from Memo m where m.mno > :num order by m.mno desc")
    List<Memo> getListDesc2(@Param("num") Long mno);

    //JPQL select문의 실행 결과를 선별적으로 받으려면 Object[]사용 합니다.
    @Query("select m.writer, m.text from Memo m where m.mno > :num order by m.mno desc")
    List<Object[]> getListDesc3(@Param("num") Long mno);

    //JPQL업데이트
    @Transactional //트랜잭션 반영
    @Modifying //업데이트임
    @Query("update Memo m set m.writer = :a where m.mno = :b")
    int updateMemo(@Param("a") String a, @Param("b") Long b);
    
    //JPQL업데이트 - 객체파라미터 를 넘기는 방법 #{객체}
    @Transactional
    @Modifying
    @Query("update Memo m set m.writer = :#{#a.writer}, m.text = :#{#a.text} where m.mno = :#{#a.mno}")
    int updateMemo(@Param("a") Memo memo);

    //delete from memo where mno = 10;
    //JPQL딜리트문 -
    @Transactional
    @Modifying
    @Query("delete from Memo m where m.mno = :a")
    int deleteMemo(@Param("a") Long mno);

    //JPQL 마지막매개변수에 Pageable을 주면, 페이지처리합니다.
    //page처리에는 countQuery가 필요합니다 (countQuery구문은 직접 작성하는게 가능함)
    @Query(value = "select m from Memo m where m.mno <= :a",
           countQuery = "select count(m) from Memo m where m.mno <= :a")
    Page<Memo> getListJPQL(@Param("a") Long mno, Pageable pageable);
    
//    select mno, writer, text, concat(writer, text) as col, current_timestamp
//    from memo
//    where mno <= 100;
//  페이지네이션 처리하는 JPQL으로
    @Query("select m.mno, m.writer, m.text, concat(m.writer, m.text) as col, current_timestamp " +
            "from Memo m where m.mno <= :a")
    Page<Object[]> getListJPQL2(@Param("a") Long mno, Pageable pageable);

    //네이티브쿼리 - JPQL이 너무 어려우면, SQL방식으로 사용하는 것을 제공해줍니다.
    @Query(value = "select * from memo where mno = ?", nativeQuery = true)
    Memo getNative(Long mno);

    //구현체에 만드는 구문은 인터페이스에서 이렇게 호출하는 것과 동일합니다.
//    @Query("select m from Memo m inner join m.member x where m.mno >= :a")
//    List<Memo> mtoJoin1(@Param("a") long a);

    @Query(value = "select new com.example.jpa.entity.MemberMemoDTO(x.id, x.name, x.signDate, m.mno, m.writer, m.text) " +
            "from Memo m left join m.member x where m.text like %:text%"
            ,countQuery = "select count(m) from Memo m left join m.member x where m.text like %:text%"
    )
    Page<MemberMemoDTO> joinPage(@Param("text") String text, Pageable pageable);









}

 

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>


    <style>
        table {
            width: 100%;
            border-collapse: collapse;
        }

        th, td {
            padding: 8px;
            text-align: left;
            border: 1px solid #ddd;
        }

        th {
            background-color: #f2f2f2;
        }

        tbody tr:nth-child(even) {
            background-color: #f9f9f9;
        }

        tbody tr:hover {
            background-color: #f1f1f1;
        }

        .pagination {
            display: flex;
            justify-content: center;
            margin-top: 20px;
            list-style: none;
            padding: 0;
        }

        .pagination li {
            margin: 0 5px;
        }

        .pagination a {
            display: block;
            padding: 8px 16px;
            text-decoration: none;
            color: #007bff;
            border: 1px solid #ddd;
            border-radius: 4px;
        }

        .pagination a.active {
            background-color: #007bff;
            color: white;
            border-color: #007bff;
        }

        .pagination a:hover {
            background-color: #ddd;
        }
    </style>


</head>
<body>

    <select name="searchType">
        <option value="mno">번호</option>
        <option value="text">내용</option>
        <option value="writer">작성자</option>
        <option value="textWriter">내용 + 작성자</option>
    </select>
    <input type="text" name="searchName">
    <button type="button" onclick="searchList()">검색</button>

    <table>
        <thead>
        <tr>
            <th>MNO</th>
            <th>Writer</th>
            <th>Text</th>
            <th>Id</th>
            <th>Name</th>
            <th>Sign Date</th>
        </tr>
        </thead>
        <tbody id="tableBody">
        <!-- Rows will be inserted here by JavaScript -->
        </tbody>
    </table>

    <ul class="pagination" id="pagination">
        <!-- Pagination buttons will be inserted here by JavaScript -->
    </ul>


    <script>

        var pagination = document.getElementById("pagination"); //페이지네이션 태그
        var page = 1;
        var amount = 10;
        var start = 0; //시작페이지네이션값
        var end = 0; //끝페이지네이션값

        //데이터 ajax요청
        function getList() {

            //searchName값
            var searchName = document.querySelector("input[name=searchName]").value;

            var url = "/getList?page=" + page + "&amount=" + amount + "&searchName=" + searchName;
            fetch(url)
            .then( function(response) {
                return response.json()
            })
            .then( function(data) {
                createBody(data.pageData) //바디 생성함수 호출
                createPage(data); //페이지네이션 생성함수
            })
        } //end

        //내용 생성 함수
        function createBody(list) { //item은 list일 것임
            var tableBody = document.getElementById("tableBody");

            var str = "";
            list.forEach( function(data) {
                str += "<tr>";
                str += "<td>" + data.mno + "</td>";
                str += "<td>" + data.writer + "</td>";
                str += "<td>" + data.text + "</td>";
                str += "<td>" + data.id + "</td>";
                str += "<td>" + data.name + "</td>";
                str += "<td>" + data.signDate + "</td>";
                str += "</tr>";
            })
            tableBody.innerHTML = str; //tbody밑에 추가

        }

        //페이지 네이션 생성함수
        function createPage(item) {
            console.log(item);

            var pageList = item.pageList; //페이지네이션값
            var next = item.next; //다음버튼
            var prev = item.prev; //이전버튼
            start = item.start; //페이지네이션 시작
            end = item.end; //페이지네이션 끝

            var str = "";
            //이전버튼
            if(prev) {
                str += "<a href='#' class='prev'>이전</a>";
            }
            //페이지 네이션
            pageList.forEach( function(data) {
                str += "<a href='#' class='number' >" + data + "</a>";
            })
            //다음버튼
            if(next) {
                str += "<a href='#' class='next'>다음</a>";
            }

            pagination.innerHTML = str;
        } //end


        //페이지네이션 이벤트 -> 페이지네이션은 뒤늦게 그려지는 태그 ( 부모에 걸고 자식에서 위임 )
        //이벤트는 부모에 검~
        pagination.addEventListener('click', function(e) {

            e.preventDefault(); //a이벤트 중단
            if(e.target.className == 'pagination' ) return; //pagenation클릭시 함수 종료

            if(e.target.className == 'prev') { //이전버튼
                page = start - 1; //시작번호의 1
            } else if(e.target.className == 'next') { //다음버튼
                page = end + 1; //끝번호의 + 1
            } else if(e.target.className == 'number') { //페이지번호
                page = e.target.innerHTML; //a태그 사이값을 전역변수 저장
            }
            getList(); //데이터 조회 메서드 호출
        });

        //검색기능 - 검색을 한다는 것은~? 다시 태초로 돌아간다는 의미.
        function searchList() {
            page = 1;
            amount = 10;
            getList();
        }

        //즉시실행함수
        (function() {
            getList(); //데이터 요청 호출
        })();



    </script>




</body>
</html>

package com.example.jpa.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Controller
public class JpaController {

    @GetMapping("/memoList")
    public String main() {
        return "memoList";
    }
}

package com.example.jpa.entity;

import lombok.*;

import javax.persistence.*;

@Entity //jpa가 엔티티로 관리한다는 의미
@Table(name = "MEMO") //MEMO테이블
@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Memo {

    //엔티티를 정의하면, 하이버네이트가 DDL구문을 대신 실행해주는데, spring.jpa.hibernate.ddl-auto=update 옵션

    @Id //pk
    @GeneratedValue(strategy = GenerationType.IDENTITY) //auto_increment동작
//    오라클전략
//    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "이름")
//    @SequenceGenerator(name = "이름", sequenceName = "시퀀스명", initialValue = 1, allocationSize = 1)
    private long mno;
    @Column(length = 200, nullable = false)
    private String writer;
    @Column(columnDefinition = "varchar(200) default 'y' ") //만들고 싶은 제약을 직접 명시
    private String text;

    //N:1
    //FK 컬럼명을 명시하지 않으면 Member엔티티에 member_주키 로 자동 생성됩니다.
//    @ManyToOne(fetch = FetchType.LAZY) //manyToOne 기본값은 EAGER방식
//    @JoinColumn(name = "member_id") //Member엔티티의 주키를 member_id컬럼에 저장하겠다(FK)
//    private Member member; //멤버 엔티티

    
    //양방향 맵핑
    @ManyToOne
    @JoinColumn(name = "member_id")
    private Member member;
    
    
}