728x90

인프런 김영한 님의 강의를 참고했습니다.

 

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

웹 애플리케이션을 개발할 때 필요한 모든 웹 기술을 기초부터 이해하고, 완성할 수 있습니다. 스프링 MVC의 핵심 원리와 구조를 이해하고, 더 깊이있는 백엔드 개발자로 성장할 수 있습니다., -

www.inflearn.com

 

스프링 부트를 설정해서 다운로드하여 오고, 추가 설정들을 해준다.

저번에 워낙 많이 해서 그냥 넘어가도록 하겠다.

 

이번에는 서블릿을 사용하기 때문에 스프링 메인에 @ServletComponentScan annotation을 달아준다.

그러고 같은 패키지 내에 이런 자바 코드를 작성해 보자.

package hello.servlet.basic;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "hiServlet", urlPatterns = "/hi")
public class HiServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        resp.setContentType("text/plain");
        resp.setCharacterEncoding("utf-8");


        PrintWriter writer = resp.getWriter();
        writer.println("HiServlet");
        writer.println("request = " + req);
        writer.println("response = " + resp);

        writer.println("name = " + req.getParameter("name"));

    }
}

실행을 하고 url에 접속한 결과이다.

 

@WebServlet annotation은 서블릿 어노테이션으로 name에 들어가는 값은 서블릿의 이름이고, urlPatterns에 들어가는 값은 mapping 되는 url이다.

저번에 서블릿 공부 할 때 공부했을 것이다.

그리고 서블릿을 사용하기 위해서는 HttpServlet을 extends 받아야 한다.

 

메서드 내의 코드를 잠깐 설명해 보자면, 응답의 ContentType을 text/plain으로 설정하고 CharacterEncoding을 utf-8로 설정을 한 후 response에 getWriter로 request와 response 객체를 출력해 보는 것이다.

 

  • HTTPServletRequest 객체

객체의 이름을 보면 알겠지만, HTTP의 Request를 Servlet이 다루기 편하게 만들어주는 객체이다.

이곳을 보면 HTTP 요청 메시지에 대한 정보를 얻어 올 수 있다.

당연히 직접 HTTP 요청 메시지를 사용할 수 있겠지만, 난이도가 매우 어렵다.

 

HTTPServletRequest 객체를 이용해서 안의 내용들을 출력해 보자.

우선 시작 줄부터이다.

주석으로 설명을 달지 않아도 시작줄의 어떤 내용을 출력하려 하는 것인지 알 수 있을 것이다.

package hello.servlet.basic.request;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "requestHeaderServlet", urlPatterns = "/requestHeader")
public class RequestHeader extends HttpServlet {

    private void printStart(HttpServletResponse httpServletResponse, String string) throws IOException {
        httpServletResponse.getWriter().printf("--- %s-Line start ---\n", string);
    }

    private void printEnd(HttpServletResponse httpServletResponse, String string) throws IOException {
        httpServletResponse.getWriter().printf("--- %s-Line end ---\n", string);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        StartLine(req, resp);
    }

    private void StartLine(HttpServletRequest request,HttpServletResponse response)throws IOException{

        response.setContentType("text/plain");
        response.setCharacterEncoding("utf-8");

        PrintWriter writer = response.getWriter();

        printStart(response, "Request");

        writer.println("Method = " + request.getMethod());
        writer.println("Protocol = " + request.getProtocol());
        writer.println("Scheme = " + request.getScheme());
        writer.println("RequestURL = " + request.getRequestURL());
        writer.println("RequestURI = " + request.getRequestURI());
        writer.println("QueryString = " + request.getQueryString());
        writer.println("isSecure = " + request.isSecure());
        printEnd(response, "Request");

        writer.println();
    }
}

실행을 한 후에 접속해 보면

이렇게 요청 메서드에 관한 정보들이 나오게 된다.

 

이번엔 헤더이다.

package hello.servlet.basic.request;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "requestHeaderServlet", urlPatterns = "/requestHeader")
public class RequestHeader extends HttpServlet {

    private void printStart(HttpServletResponse httpServletResponse, String string) throws IOException {
        httpServletResponse.getWriter().printf("--- %s-Line start ---\n", string);
    }

    private void printEnd(HttpServletResponse httpServletResponse, String string) throws IOException {
        httpServletResponse.getWriter().printf("--- %s-Line end ---\n", string);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        StartLine(req, resp);
        Headers(req, resp);
    }

    private void Headers(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/plain");
        response.setCharacterEncoding("utf-8");

        PrintWriter writer = response.getWriter();

        printStart(response, "Headers");

        request.getHeaderNames().asIterator()
                .forEachRemaining(headerName -> writer.println(headerName + " = " + request.getHeader(headerName)));

        printEnd(response, "Headers");
        writer.println();
    }
}

이번엔 Iterator로 빠르게 출력했다.

이렇게 이어서 잘 출력이 되는 것을 볼 수 있다.

나머지 부분들도 request를 보면 찾을 수 있지만, 이 정도만 하고 넘어가 보겠다.

 

  • HTTP request - GET

데이터를 서버로 전송해 보자.

서버로 데이터를 전송할 때는 Postman을 사용하면 된다.

package hello.servlet.basic.request;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet(name = "requestParam", urlPatterns = "/requestParam")
public class RequestParam extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("[파리미터 조회] - start");
        req.getParameterNames().asIterator()
                .forEachRemaining(paramName -> System.out.println(paramName + " = " + req.getParameter(paramName)));

        System.out.println("[파리미터 조회] - end");
        System.out.println();

        System.out.println("[개별 파라미터 조회]");
        System.out.println("name : " + req.getParameter("name"));
        System.out.println("age: " + req.getParameter("age"));

        System.out.println();
    }
}

이렇게 Iterator를 이용하여 전체를 조회할 수 있지만, 보통 getParameter()를 이용해서 개별 조회를 한다.

Postman으로 데이터를 전송하면

이렇게 출력되게 된다.

 

  • HTTP request - POST

이번엔 POST 방식이다.

저번 GET 방식은 URL로 데이터를 보낼 수도 있긴 했지만, 이번 POST 방식은 Postman을 이용해야 할 것이다.

근데 코드는 수정할 필요가 없다.

POST 방식도 GET과 쿼리 파라미터 형식이 같기 때문에 조회 메서드는 동일하게 사용할 수 있다.

이렇게 동일한 결과가 나오는 것을 볼 수 있다.

 

  • HTTP request - 텍스트
package hello.servlet.basic.request;

import jakarta.servlet.ServletException;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.util.StreamUtils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

@WebServlet(name = "requestBodyString", urlPatterns = "/requestBodyString")
public class RequestBodyString extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletInputStream inputStream = req.getInputStream();

        String message = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);

        System.out.println("message = " + message);

    }
}

InputStream은 바이트 코드를 반환하기 때문에 UTF_8로 지정을 해주어 바꿔줘야 한다.

 

Postman으로 POST에 raw로 그냥 메시지를 보내면

이렇게 잘 출력이 되는 것을 볼 수 있다.

 

  • HTTP request - JSON

요즘 많이 사용하는 JSON 형식이다.

우선 Postman에서 JSON으로 데이터를 보내는 방법부터 알아보겠다.

Body에서 raw, JSON을 선택하고 형식에 맞게 작성을 하면 된다.

 

그러고 JSON 형식으로 데이터를 가져올 수 있게 그에 맞는 객체를 생성한다.

package hello.servlet.basic;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class JsonData {
    private String name;
    private int age;
}

깔끔하게 Lombok을 사용한다.

 

package hello.servlet.basic.request;

import com.fasterxml.jackson.databind.ObjectMapper;
import hello.servlet.basic.JsonData;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.util.StreamUtils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

@WebServlet(name = "requestBodyJson", urlPatterns = "/requestBodyJson")
public class RequestBodyJson extends HttpServlet {
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletInputStream inputStream = req.getInputStream();
        String message = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
        
        JsonData jsonData = objectMapper.readValue(message, JsonData.class);

        System.out.println(jsonData);
    }
}

ObjectMapper를 이용해서 가져온 데이터를 해당 객체로 변환해 준다.

이렇게 잘 출력되는 것을 볼 수 있다.

 

  • HTTP response

HttpServletResponse를 사용하여 응답 메시지를 작성할 수 있다.

package hello.servlet.basic.response;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet(name = "responseHeader", urlPatterns = "/response-header")
public class ResponseHeaderServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //상태 라인
        resp.setStatus(HttpServletResponse.SC_OK);
        
        //response header
        resp.setContentType("text/plain");
        resp.setCharacterEncoding("utf-8");
        resp.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
        resp.setHeader("Pragma", "no-cache");
        resp.setHeader("my-header", "hi");
        
    }
    
    private void redirect(HttpServletResponse response) throws IOException{
        response.sendRedirect("/basic/hi-form.html");
    }
    
    private void cookie(HttpServletResponse response){
        Cookie cookie = new Cookie("myCookie", "good!");
        cookie.setMaxAge(60);
        response.addCookie(cookie);
    }
}

이렇게 response 객체를 이용해서 편하게 응답 메시지를 만들 수 있다.

 

이번에는 중요한 응답 메시지로 JSON을 작성하는 방법이다.

여기서도 ObjectMapper를 사용한다.

package hello.servlet.basic.response;

import com.fasterxml.jackson.databind.ObjectMapper;
import hello.servlet.basic.JsonData;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet(name = "responseJson", urlPatterns = "/responseJson")
public class ResponseJson extends HttpServlet {
    
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("application/json");
        resp.setCharacterEncoding("utf-8");
        
        JsonData jsonData = new JsonData();
        jsonData.setName("hi");
        jsonData.setAge(20);
        
        String result = objectMapper.writeValueAsString(jsonData);
        
        resp.getWriter().write(result);
    }
}

이렇게 객체를 만들고 ObjectMapper를 이용하여 문자열로 바꿔준 후 write로 작성을 해주면 된다.

그러면 이렇게 잘 전달이 되는 것을 볼 수 있다.

'Spring > 스프링' 카테고리의 다른 글

스프링 16일차  (0) 2023.03.29
스프링 15일차  (0) 2023.03.28
스프링 13일차  (0) 2023.03.25
스프링 12일차  (0) 2023.02.15
스프링 11일차  (0) 2023.02.12
728x90

인프런 김영한님의 강의를 참고했습니다.

 

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

웹 애플리케이션을 개발할 때 필요한 모든 웹 기술을 기초부터 이해하고, 완성할 수 있습니다. 스프링 MVC의 핵심 원리와 구조를 이해하고, 더 깊이있는 백엔드 개발자로 성장할 수 있습니다., -

www.inflearn.com

HTTP와 JPA 공부를 어느정도 끝내고 다시 스프링으로 돌아왔다.

 

HTTP의 기본도 공부를 했으니

오늘은 스프링이 어떻게 돌아가는지 알아보기 위해 WAS와 그 기원인 tomcat, Servlet & JSP등을 알아보고 온다.

 

  • Web Server, WAS

Web Server

HTTP 기반으로 동작을 하며, 정적 리소스를 제공한다.

정적 리소스라하면 단순한 파일들인 HTML, CSS, JPG 등을 말한다.

 

WAS(Web Application Server)

이 친구도 마찬가지로 HTTP 기반으로 동작한다.

정적 리소스도 제공은 가능하기 때문에 Web Server의 기능을 수행할 수도 있기는 하다.

그러고도 프로그램 코드를 실행 가능하기 때문에 애플리케이션 로직을 수행할 수 있다.

예를 들면 저번에 공부했던 tomcat이 있다.

 

그렇기 때문에 웹 시스템을 WAS와 DB만으로 구성이 가능하다.

WAS는 웹 서버의 기능을 수행할 수 있기 때문이다.

 

하지만 이렇게 만들면 WAS가 너무 많은 역할을 담당한다.

WAS는 복잡한 로직들을 수행하기 때문에 장애가 많이 일어나고, 이 때문에 정적 리소스조차 수행 불가능 할 수 있다.

그렇기 때문에 정적 리소스는 웹 서버가 처리하고 로직은 WAS가 수행하도록 섞어서 사용하게 된다.

 

Web Server는 WAS에 비해 장애가 발생하지 않기 때문에 WAS에 장애가 생기면 Web Server를 통해 오류 화면을 제공할 수도 있다.

 

  • Servlet

서블릿은 저번에 공부 했던 내용이다.

서블릿을 사용하면 HTTP 송수신 과정에서 애플리케이션 로직들만 신경 쓸 수 있게 해준다.

HTTP를 요청하면 WAS는 Request, Response 객체를 만들어서 서블릿 객체를 호출한다.

그러면 그 Request, Response 객체를 받아서 Request를 보고 HTTP 요청 정보를 확인하고, Response에 응답 정보를 입력한다.

 

위 그림처럼 서블릿을 지원하는 WAS를 서블릿 컨테이너라고 한다.

저 컨테이너는 서블릿 객체들을 생성하고 객체들의 생명주기를 관리한다.

객체들은 Spring과 같이 계속 생성하는 비효율적이기 때문에 싱글톤으로 관리한다.

이 싱글톤 객체들을 어떻게 사용하는 것이 좋으며, 주의해야 하는 부분은 무엇인지 알고 있을 것이다.

 

  • 멀티 쓰레드

만약 서버가 단일 쓰레드라면?

먼저 들어온 요청이 모두 끝난 후에 다음 요청이 쓰레드를 사용하여 응답을 받을 수 있을 것이다.

이렇게되면 다음에 들어온 요청은 대기 시간이 굉장히 길어질 것이다.

여기서 먼저 들어온 요청에 장애가 생겨서 쓰레드를 반환하지 않는다면 다음 요청은 평생 응답을 받을 수 없을 것이다.

 

그렇다고 해서 요청마다 쓰레드를 생성한다면 쓰레드를 생성할 때마다 굉장히 오랜 시간이 걸리며, 고객의 요청이 너무 많이 오면 서버의 CPU와 메모리가 다운될 수 있다.

 

그렇기 때문에 미리 쓰레드들을 만들어놓고 도서관에서 책 빌리는 것 처럼 하나씩 쓰레드를 빌리고 반납하는 형식으로 사용한다.

만약 쓰레드 풀에 남은 쓰레드가 없다면 쓰레드를 대기하게 된다.

이렇게하면 쓰레드가 미리 생성되어 있기 때문에 생성하는 시간을 줄일 수 있다.

 

  • HTML, HTTP API, 렌더링

위에서 말했듯이 고정된 HTML 파일들은 웹 브라우저를 사용하여 제공하면 된다.

사용자에 따라 달라지는 동적 HTML 페이지는 WAS를 사용하여 제공한다.

 

만약 HTML이 아닌 데이터만을 전달하는 것이 목적이라면 굳이 HTML에 담아서 전달할 필요가 없다.

WAS에서 주로 JSON 형식으로 주고 받는다.

 

그러면 여기서 렌더링 방식에 따라 서버사이드 렌더링, 클라이언트 사이드 렌더링으로 나뉜다.

SSR(서버 사이드 렌더링) CSR(클라이언트 사이드 렌더링)
HTML 최종 결과를 서버에서 만들어서 클라이언트에 전달 HTML 결과를 자바스크립트를 사용해 동적으로 생성해서 적용
보통 정적인 화면에 사용한다. 보통 동적인 화면에 사용
JSP, Thymeleaf React, Vue.js

SSR은 서버에서 다 받아오기 때문에 바로 이해할 수 있을 것 같고

CSR은 이런 과정을 거쳐 렌더링이 된다.

 

'Spring > 스프링' 카테고리의 다른 글

스프링 15일차  (0) 2023.03.28
스프링 14일차  (0) 2023.03.26
스프링 12일차  (0) 2023.02.15
스프링 11일차  (0) 2023.02.12
스프링 10일차  (0) 2023.02.11
728x90

초반부에 빠르게 넘어갔던 영속 컨텍스트와 LifeCycle에 대해 좀 더 자세히 알아보자.

 

  • 영속 컨텍스트

영속 엔티티는 DB 데이터에 매핑되는 메모리상의 객체이다.

엔티티라고 하면 우리가 무수히 만들었던 Entity가 생각이 날 것이다.

 

영속 컨텍스트는 메모리 저장소로 엔티티들을 보관하고 있다.

EntityManager로 관리를 하며, EntityManager.close()를 호출하면 영속 컨텍스트를 제거한다.

영속 컨텍스트는 동일 식별자를 가지면 그 엔티티들은 동일한 엔티티로 판단한다.

 

그렇기 때문에

System.out.println("first find");
User first = entityManager.find(User.class, email1);
System.out.println("second find");
User second = entityManager.find(User.class, email2);
logger.info("same object: {}", (first == second));

이렇게 동일 식별자를 가진 데이터를 2번 조회하게 되면

first find
select로 해당 데이터 조회
second find
//select 쿼리가 실행되지 않음
same object: true

이렇게 조회하는 쿼리가 한 번만 실행되는데, 같은 엔티티라고 판단해서 다시 조회하지 않고 영속 컨테이너에서 가져오기 때문이다.

 

  • 영속 객체 LifeCycle

조회(find)나 persist()를 통해서 영속 컨텍스트에 저장이 된 객체는 관리 대상이 된다.

관리 대상에서 제외하고 싶으면 detach()를 사용하면 된다.

close()를 사용해도 manager가 닫히기 때문에 더 이상 관리되지 않는다.

 

'Spring > JPA' 카테고리의 다른 글

JPA 9장 (Map collection mapping)  (0) 2023.03.21
JPA 8장 (List collection mapping)  (0) 2023.03.18
JPA 7장 (Set collection mapping)  (0) 2023.03.18
JPA 6장 (@Embeddable)  (0) 2023.03.17
JPA 5장 (Entity 식별자 생성 방식)  (0) 2023.03.16
728x90

이번엔 Map을 mapping 해본다.

 

이런 테이블이 있다고 해보자.

import jakarta.persistence.*;

import java.util.HashMap;
import java.util.Map;

@Entity
@Table(name = "book")
public class book {
    @Id
    private String id;
    private String title;
    private String content;
    @ElementCollection
    @CollectionTable(
            name = "book_prop",
            joinColumns = @JoinColumn(name="book_id")
    )
    @MapKeyColumn(name = "name")
    @Column(name = "value")
    private Map<String, String> props = new HashMap<>();

    protected book(){}

    public book(String id, String title, String content, Map<String, String> props) {
        this.id = id;
        this.title = title;
        this.content = content;
        this.props = props;
    }
    
    //getter... setter...
}

이렇게 @CollectionTable로 저장할 테이블을 지정을 해주고

Map에 들어간 데이터를 어떤 column에 넣어줄지 PK는 @MapKeyColumn에, 그냥 데이터는 @Column으로 지정을 해준다.

 

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;

import java.util.HashMap;
import java.util.Map;

public class book_main {

    public static void main(String[] args) {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpabegin");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        Map<String, String> props1 = new HashMap<>();
        Map<String, String> props2 = new HashMap<>();

        props1.put("name1", "value1");
        props1.put("name2", "value2");
        book book1 = new book("1", "이름", "내용", props1);
        book book2;

        try{
            entityTransaction.begin();
            entityManager.persist(book1);
            entityTransaction.commit();
        }catch(NullPointerException exception){
            throw new NullPointerException();
        }

        try{
            book2 = entityManager.find(book.class, "1");
        }catch(NullPointerException exception){
            throw new NullPointerException();
        }

        System.out.println("book: " + book2);
        System.out.println("props: " + book2.getProps());
    }
}

이렇게 추가를 하고 조회를 하면

정상 작동하는 것을 볼 수 있다.

 

늘 그렇듯이 이번엔 Embeddable 타입이다.

이런 테이블이 있다고 하고, 여기서 PropValue를 Embeddable로 만들 생각이다.

우선 Embeddable 타입을 먼저 작성한다.

import jakarta.persistence.Access;
import jakarta.persistence.AccessType;
import jakarta.persistence.Embeddable;

@Embeddable
@Access(AccessType.FIELD)
public class PropValue {
    private String value;
    private boolean enabled;

    public PropValue(String value, boolean enabled) {
        this.value = value;
        this.enabled = enabled;
    }

    protected PropValue () {}
	
    //getter...setter...
    
    @Override
    public String toString() {
        return "PropValue{" +
                "value='" + value + '\'' +
                ", enabled=" + enabled +
                '}';
    }
}

이렇게 항상 작성하던 @Embeddable을 작성하고

import jakarta.persistence.*;

import java.util.HashMap;
import java.util.Map;

@Entity
@Table(name = "book")
public class book2 {
    @Id
    private String id;
    private String title;
    private String content;
    @ElementCollection
    @CollectionTable(
            name = "book_prop",
            joinColumns = @JoinColumn(name = "book_id")
    )
    @MapKeyColumn(name = "name")
    private Map<String, PropValue> props = new HashMap<>();

	//getter...setter...
    
    @Override
    public String toString() {
        return "book2{" +
                "id='" + id + '\'' +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", props=" + props +
                '}';
    }
}

@MapKeyColumn을 이용해서 그랬던 것처럼 작성을 해준다.

여기에 Map의 타입에 <PK, @Embeddable>을 넣어서 작성해준다.

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;

import java.util.HashMap;
import java.util.Map;

public class book_main2 {

    public static void main(String[] args) {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpabegin");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        Map<String, PropValue> Propvalues = new HashMap<>();

        PropValue propValue1 = new PropValue("value1", true);
        PropValue propValue2 = new PropValue("value2", true);

        Propvalues.put("String1", propValue1);
        Propvalues.put("String2", propValue2);

        book2 book1 = new book2("id1", "title1", "content1", Propvalues);
        book2 book2;

        try{
            entityTransaction.begin();
            entityManager.persist(book1);
            entityTransaction.commit();
        }catch (NullPointerException exception){
            throw new NullPointerException();
        }

        try{
            book2 = entityManager.find(book2.class, "id1");
            System.out.println(book2);
        }catch(NullPointerException exception){
            throw new NullPointerException();
        }finally {
            entityManager.close();
        }

        entityManagerFactory.close();

    }
}

이렇게 동작하는 것을 볼 수 있다.

'Spring > JPA' 카테고리의 다른 글

JPA 10장 (영속 컨텍스트와 LifeCycle)  (0) 2023.03.22
JPA 8장 (List collection mapping)  (0) 2023.03.18
JPA 7장 (Set collection mapping)  (0) 2023.03.18
JPA 6장 (@Embeddable)  (0) 2023.03.17
JPA 5장 (Entity 식별자 생성 방식)  (0) 2023.03.16
728x90

이번엔 List이다.

문제에 관련된 DB가 있다고 하자.

테이블은

question
id varchar(10)
text varchar(20)
question_choice
question_id varchar(10)
idx integer(10)
text varchar(20)

그러면 question안에 객관식 보기인 question_choice들이 순서대로 들어가 있어야 할 것이다.

이런 경우에는 순서가 존재하기 때문에 저번에 사용한 Set을 사용할 수 없고, List를 사용해야 한다.

import jakarta.persistence.*;

import java.util.List;

@Entity
@Table(name = "question")
public class question {
    @Id
    private String id;
    private String text;

    @ElementCollection
    @CollectionTable(
            name = "question_choice",
            joinColumns = @JoinColumn(name = "question_id")
    )
    @OrderColumn(name = "idx")
    @Column(name = "text")
    private List<String> choices;

    protected question () {}

    public question(String id, String text, List<String> choices) {
        this.id = id;
        this.text = text;
        this.choices = choices;
    }
    //getter... settter
}
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;

import java.util.List;

public class questionMain {

    public static void main(String[] args) {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpabegin");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        try{
            entityTransaction.begin();
            question question1 = new question("1", "문제1", List.of("1번", "2번", "3번", "4번", "5번"));
            entityManager.persist(question1);
            entityTransaction.commit();
        }catch (Exception ignored){

        }

        try{
            question question2 = entityManager.find(question.class,"1");
            for(String choice : question2.getChoices()){
                System.out.println(choice);
            }
        }finally {
            entityManager.close();
        }

        entityManagerFactory.close();
    }
}

이렇게 Set과 똑같이 작성하지만, @OrderColumn을 추가해준다.

당연히 @Embedded도 사용이 가능하다.

import jakarta.persistence.Embeddable;

@Embeddable
public class choice {
    private String text;
    private boolean input;

    protected choice() {}

    public choice(String text, boolean input) {
        this.text = text;
        this.input = input;
    }

	//getter... setter...
}
import jakarta.persistence.*;

import java.util.List;

@Entity
@Table(name = "question")
public class question2 {
    @Id
    private String id;
    private String text;

    @ElementCollection
    @CollectionTable(
            name = "question_choice",
            joinColumns = @JoinColumn(name = "question_id")
    )
    @OrderColumn(name = "idx")
    private List<choice> choiceList;

    protected question2 (){}

    public question2(String id, String text, List<choice> choiceList) {
        this.id = id;
        this.text = text;
        this.choiceList = choiceList;
    }
	//getter... setter...
}
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;

import java.util.List;

public class questionMain2 {

    public static void main(String[] args) {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpabegin");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        try{
            entityTransaction.begin();
            question2 question1 = new question2("1", "문제1", List.of(new choice("1", false),
                    new choice("2", true)));
            entityManager.persist(question1);
            entityTransaction.commit();
        }catch (Exception ignored){

        }

        try{
            question2 question2 = entityManager.find(question2.class,"1");
            for(choice choice : question2.getChoiceList()){
                System.out.println(choice.getInput() + ", " + choice.getText());
            }
        }finally {
            entityManager.close();
        }

        entityManagerFactory.close();
    }
}

'Spring > JPA' 카테고리의 다른 글

JPA 10장 (영속 컨텍스트와 LifeCycle)  (0) 2023.03.22
JPA 9장 (Map collection mapping)  (0) 2023.03.21
JPA 7장 (Set collection mapping)  (0) 2023.03.18
JPA 6장 (@Embeddable)  (0) 2023.03.17
JPA 5장 (Entity 식별자 생성 방식)  (0) 2023.03.16
728x90

 

이런 테이블들이 있다고 해보자.

job
id VARCHAR(10)
name VARCHAR(100)

 

job_perm
job_id VARCHAR(10)
permission VARCHAR(20)

 

이렇게 job 안에 permission에 해당 하는 값들을 보관하고 있어야 한다.

import jakarta.persistence.*;

import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "job")
public class job {
    @Id
    private String id;
    private String name;

    @ElementCollection
    @CollectionTable(
            name="job_perm", //job_perm 테이블 명
            joinColumns = @JoinColumn(name = "job_id") //job_perm 테이블의 job_id column
    )
    @Column(name = "perm") //job_perm 테이블의 permission column
    private Set<String> permissions = new HashSet<>();

    protected job() {}

    public job(String id, String name, Set<String> permissions) {
        this.id = id;
        this.name = name;
        this.permissions = permissions;
    }
	//getter... setter...
    public Set<String> getPermissions() {
        return permissions;
    }

    public void setPermissions(Set<String> permissions) {
        this.permissions = permissions;
    }
}

이렇게 내부에 Set을 만들고 @ElementCollection을 작성해준다.

 

한 번에 이해하기 힘들테니 바로 실행을 해보고 결과를 확인해보자.

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.Persistence;

import java.util.Set;

public class roleMain{
    public static void main(String[] args) {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("jpabegin");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        try{
            entityTransaction.begin();
            job job1 = new job("1", "안녕", Set.of("11", "22"));
            entityManager.persist(job1);
            entityTransaction.commit();
        }catch(Exception ignored){

        }

        try{
            job job2 = entityManager.find(job.class, "1");
            for(String perm : job2.getPermissions()){
                System.out.println(perm);
            }
        }finally {
            entityManager.close();
        }

        entityManagerFactory.close();
    }
}

job을 persist 할 때 Set에 11, 22에 해당하는 값을 입력해주면

이렇게 job 테이블에 데이터 하나가 추가가 되고

job_perm 테이블에는 집합으로 넣었던 데이터 2개가 추가가 된다.

find로 조회할 때는

class에 작성했던 getPermission을 통해 for-each문으로 가져오면 된다.

 

당연히 Embeddable 타입도 가능하다.

이런 관계에서도 위와 비슷하게 @Embeddable 클래스만 만들어주고 동일 작업을 수행하면 된다.

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;

@Embeddable
public class information {
    @Column(name = "perm")
    private String permission;
    private String info;

    protected information () {}

    public information(String permission, String info) {
        this.permission = permission;
        this.info = info;
    }
    
    //getter... setter
}
import jakarta.persistence.*;

import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name="role")
public class job2 {
    @Id
    private String id;
    private String name;

    @ElementCollection
    @CollectionTable(
            name="role_perm",
            joinColumns = @JoinColumn(name = "role_id")
    )
    private Set<information> informationSet = new HashSet<>();

    protected job2(){}

    public job2(String id, String name, Set<information> informationSet) {
        this.id = id;
        this.name = name;
        this.informationSet = informationSet;
    }
	//getter... setter...
    public Set<information> getInformationSet() {
        return informationSet;
    }

    public void setInformationSet(Set<information> informationSet) {
        this.informationSet = informationSet;
    }
}

이렇게 정상적으로 작동하게 된다.

'Spring > JPA' 카테고리의 다른 글

JPA 9장 (Map collection mapping)  (0) 2023.03.21
JPA 8장 (List collection mapping)  (0) 2023.03.18
JPA 6장 (@Embeddable)  (0) 2023.03.17
JPA 5장 (Entity 식별자 생성 방식)  (0) 2023.03.16
JPA 4장 (Entity에 대하여)  (0) 2023.03.16
728x90

@Embeddable annotation에 대해 배워보자.

 

테이블에 값을 저장할 때 

title date category publisher writer_name writer_mail
... ... ... ... ... ...

writer_name, witer_mail 같이 서로 묶이면 더 보기 편할 거 같은 column들이 있다.

이럴 때 @Embeddable을 사용한다.

@Embeddable은 엔티티가 아닌 타입을 한 개 이상의 필드와 매핑할 때 사용한다.

 

package user;

import jakarta.persistence.Embeddable;

@Embeddable
public class school {

    private String elementarySchool;
    private String middleSchool;
    private String highSchool;

    public school(String elementarySchool, String middleSchool, String highSchool) {
        this.elementarySchool = elementarySchool;
        this.middleSchool = middleSchool;
        this.highSchool = highSchool;
    }

    protected school() {

    }

	//getter..., setter...
}

예시를 보자.

학교와 관련된 column들을 school이라는 클래스에 묶었다.

당연히 여기서 변수 명들은 각자의 column명과 일치하거나, 일치하지 않는다면 @Column으로 mapping을 해주어야 한다.

그리고 school이라는 클래스에 @Embeddable을 달아준다.

 

이제 테이블에 해당하는 클래스를 작성하자.

package user;

import jakarta.persistence.*;

@Entity
@Table(name = "user")
public class user {

    @Id
    private String email;
    private String name;
    @Embedded
    private school school;

    protected user() {
    }

    public user(String email, String name, school school) {
        this.email = email;
        this.name = name;
        this.school = school;
    }

	//getter... setter...
}

그러고 Id에 해당하는 멤버에 @Embedded를 달아준다.

이렇게 정상적으로 생성과 조회가 되는 것을 볼 수 있다.

 

만약 여기 school에 null을 넣어준다면, school에 들어있는 column의 값들에도 모두 null이 들어가게 된다.

 

같은 @Embeddable 타입 필드가 두 개라면 어떻게 될까?

당연히 에러가 난다.

 

그럴 때는 뒤에 오는 column은 @AttributeOverride로 설정을 재정의 해줘야 한다.

package school;

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;

@Embeddable
public class info {

    @Column(name = "eleaddr")
    private String addr;
    @Column(name = "elenum")
    private String num;

    protected info(){}

    public info(String addr, String num) {
        this.addr = addr;
        this.num = num;
    }
    //getter... setter...
}
package school;

import jakarta.persistence.*;

@Entity
@Table(name = "school_table")
public class school {

    @Id
    @Embedded
    private info elementInfo;

    @AttributeOverrides({
            @AttributeOverride(name = "addr", column = @Column(name = "midaddr")),
            @AttributeOverride(name = "num", column = @Column(name = "midnum")),
    })
    @Embedded
    private info midInfo;

    protected school () {}

    public school(info elementInfo, info midInfo) {
        this.elementInfo = elementInfo;
        this.midInfo = midInfo;
    }
}

이렇게 info에 mapping 되는 변수가 2개 있으면 하나를 @AttributeOverride로 재정의 해준다.

그러면 충돌이 일어나지 않고 정상적으로 생성, 조회가 되는 것을 볼 수 있다.

'Spring > JPA' 카테고리의 다른 글

JPA 8장 (List collection mapping)  (0) 2023.03.18
JPA 7장 (Set collection mapping)  (0) 2023.03.18
JPA 5장 (Entity 식별자 생성 방식)  (0) 2023.03.16
JPA 4장 (Entity에 대하여)  (0) 2023.03.16
JPA 3장 (간단한 CRUD 구현해보기)  (0) 2023.03.16
728x90
  • 직접 할당

@Id 설정 대상에 직접 값 설정

저장하기 전에 생성자를 할당한다, 보통 생성 시점에 전달

@Entity
@Table(name = "user1")
public class User1{
    @Id
    private String name;
    private String email;
    
    protected User() {}
    
    public User (String name, String email){
    	this.name = name;
        this.email = email;
	}
}

이렇게 가장 단순한 방법으로 생성하는 방식이다.

  • 식별 칼럼 방식

칼럼 중에 auto_increment 같이 객체 생성시에 식별값을 설정하지 않는 경우가 있다.

그럴 때에는 설정을 추가하여 persist()를 실행할 때 객체에 식별자 값을 할당하게 할 수 있다.

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

@Entity
public class User2{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    
    protected User2(){}

    public User2(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

그 외에도 몇가지 방식이 더 있지만 많이 사용하지 않기 때문에 이렇게만 알아보도록 하겠다.

'Spring > JPA' 카테고리의 다른 글

JPA 7장 (Set collection mapping)  (0) 2023.03.18
JPA 6장 (@Embeddable)  (0) 2023.03.17
JPA 4장 (Entity에 대하여)  (0) 2023.03.16
JPA 3장 (간단한 CRUD 구현해보기)  (0) 2023.03.16
JPA 2장 (영속 컨텍스트)  (0) 2023.03.15

+ Recent posts