[Spring] 스프링 기초 (3)

Notice

Recent Posts

Recent Comments

Link

« 2025/05 »
일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

Tags more

Archives

Today

Total

관리 메뉴

hades

[Spring] 스프링 기초 (3) 본문

🏃🏻‍♂️ 기본훈련/Spring

[Spring] 스프링 기초 (3)

hades1 2024. 7. 27. 11:12

프로젝트 환경설정

H2와 Thymeleaf 동작 확인 후, application.yml 파일 생성

Spring:
  datasource:
    url: jdbc:h2:tcp://localhost/~/jpashop;
    username : sa
    password:
    driver-class-name: org.h2.Driver

  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
#        show_sql: true
        format_sql: true

logging:
  level:
    org.hibernate.SQL: debug

ddl-auto: create는 애플리케이션 실행 시점에 테이블을 새로 생성한다.

Member Entity

package jpabook.jpashop;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class Member {

    @Id
    @GeneratedValue
    private Long id;

    private String username;
}

@Id로 인해 id가 자동으로 primary key로 등록되고, @GeneratedValue에 의해 자동으로 값이 부여된다.

MemberRepository

package jpabook.jpashop;

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository
public class MemberRepository {

    @PersistenceContext
    private EntityManager em;

    public Long save(Member member){
        em.persist(member);
        return member.getId(); 
    }

    public Member find(Long id){
        return em.find(Member.class, id);
    }
}

persist는 데이터베이스에 등록하는 역할을 한다.

find에서 member 전체가 아닌 id만 return 하는 이유는 커맨드와 쿼리를 분리하고, id만으로도 나중에 찾을 수 있기 때문이다.

Test

package jpabook.jpashop;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(SpringExtension.class)
@SpringBootTest
class MemberRepositoryTest {

    @Autowired
    MemberRepository memberRepository;

    @Test
    public void testMember() throws Exception {
        //given
        Member member = new Member();
        member.setUsername("신짱구");

        //when
        Long saveId = memberRepository.save(member);

        //then
        Member findMember = memberRepository.find(saveId);
        Assertions.assertThat(findMember.getId()).isEqualTo(member.getId());
        Assertions.assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
    }
}

도메인 분석 설계

요구사항 분석

도메인 모델과 테이블 설계

한 회원은 여러 개의 주문을 할 수 있으므로 일대다 관계이다.

주문 하나 당 여러 개의 상품이 있을 수 있고, 상품 하나와 관련된 주문이 여러 개 있을 수 있으므로, 다대다 관계이지만, 중간에 주문상품이라는 것을 넣어 일대다+다대일로 구성한다.

한 상품은 여러 카테고리에 속할 수 있고, 한 카테고리 안에 여러 개의 상품이 속할 수 있으므로, 다대다 관계이다.

다대다 관계는 관계형 데이터베이스는 물론이고 엔티티에서도 거의 사용하지 않는다. 따라서 그림처럼 주문상품이라는 엔티티를 추가해서 다대다 관계를 일대다+다대일 관계로 변경한다.

엔티티 분석

참고) 회원이 주문을 하기 때문에, 회원이 주문리스트를 가지는 것은 얼핏 보면 잘 설계한 것 같지만, 객체 세상은 실제 세계와는 다르다. 실무에서는 회원이 주문을 참조하지 않고, 주문이 회원을 참조하는 것으로 충분하다. 여기서는 일대다, 다대일의 양방향 연관관계를 설명하기 위해서 추가했다. 가급적이면 양방향 연관관계보다는 단방향 연관관계를 쓰는 것이 좋다.

테이블 분석

연관관계의 주인은 FK(외래키)가 있는 쪽의 멤버이다.

엔티티 클래스 개발

실무에서는 가급적 Getter는 열어두고, Setter는 꼭 필요한 경우에만 사용하는 것을 추천한다고 하신다.

Member

package jpabook.jpashop.domain;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
public class Member {

    @Id
    @GeneratedValue
    @Column(name="member_id")   // 테이블에 행 이름을 member_id로 설정
    private Long id;

    private String name;

    @Embedded   // Address 필드들이 Member 클래스의 필드로 포함될 수 있음
    private Address address;

    @OneToMany(mappedBy = "member") // Member:Order=일:다, Order 클래스에서 member로 매핑되는 입장이라는 의미
    private List<Order> orders = new ArrayList<>();
}

Address

package jpabook.jpashop.domain;

import jakarta.persistence.Embeddable;
import lombok.Getter;

@Embeddable // 클래스에 필드로 포함시킬 수 있음.
@Getter
public class Address {

    private String city;
    private String street;
    private String zipcode;

    protected Address() {
    }

    public Address(String city, String street, String zipcode) {
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }
}

값은 변경하지 못하도록 설계해야 한다.

Order

package jpabook.jpashop.domain;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order {

    @Id
    @GeneratedValue
    @Column(name = "order_id")  // 테이블에 이름이 order_id인 행에 저장하겠다는 의미
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)  // Order:Member = 다:일
    @JoinColumn(name = "member_id")     // member_id 행 생성 후, Member Entity의 PK와 자동 매핑
    private Member member;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)  // Order:OrderItem = 일:다
    private List<OrderItem> orderItems = new ArrayList<>();

    @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name="delivery_id")
    private Delivery delivery;

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)    // EnumType.ORDINAL은 문제가 발생할 수 있으므로, 반드시 STRING으로 설정
    private OrderStatus status;

    // 연관관계 메소드, 위치는 핵심적으로 컨트롤하는 부분
    public void setMember(Member member){
        this.member = member;
        member.getOrders().add(this);
    }

    public void addOrderItem(OrderItem orderItem){
        orderItems.add(orderItem);
        orderItem.setOrder(this);
    }

    public void setDelivery(Delivery delivery){
        this.delivery = delivery;
        delivery.setOrder(this);
    }
}

연관관계 메소드는 당연히 실행시켜야 동작한다.

OrderItem

package jpabook.jpashop.domain;

import jakarta.persistence.*;
import jpabook.jpashop.domain.item.Item;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
public class OrderItem {

    @Id
    @GeneratedValue
    @Column(name = "order_item_id") // 테이블에 order_item_id 행에 저장
    private Long id;

    @ManyToOne
    @JoinColumn(name = "item_id")   // item_id 행과 연결
    private Item item;

    @ManyToOne
    @JoinColumn(name = "order_id")  // order_id 행과 연결
    private Order order;

    private int orderPrice;

    private int count;
}

Item

package jpabook.jpashop.domain.item;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)   // 테이블 하나에 다 저장할 것이라는 의미
@DiscriminatorColumn(name = "dtype")    // dtype이라는 행에 있는 값으로 구분할 것이라는 의미
@Getter
@Setter
public abstract class Item {    // 추상 클래스는 메소드가 구현되어 있지 않은 것. 구현체마다 다른 메소드 구현 가능

    @Id
    @GeneratedValue
    @Column(name = "item_id")
    private Long id;

    private String name;

    private int price;

    private int stockQuantity;
}

Book, Movie, Album에서 복제해서 사용하기 위해 추상 클래스로 생성하였다. OrderItem과 Item은 단방향 관계이므로, MappedBy가 없다!

Book

package jpabook.jpashop.domain.item;

import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import lombok.Getter;
import lombok.Setter;

@Entity
@DiscriminatorValue("B")	// dtype=B
@Getter
@Setter
public class Book extends Item {
    private String author;
    private String isbn;
}

Movie

package jpabook.jpashop.domain.item;

import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import lombok.Getter;
import lombok.Setter;

@Entity
@DiscriminatorValue("M")	// dtype=M
@Getter
@Setter
public class Movie extends Item {
    private String director;
    private String actor;
}

Album

package jpabook.jpashop.domain.item;

import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import lombok.Getter;
import lombok.Setter;

@Entity
@DiscriminatorValue("A")	// dtype=A
@Getter
@Setter
public class Album extends Item {
    private String artist;
    private String etc;
}

Category

package jpabook.jpashop.domain;

import jakarta.persistence.*;
import jpabook.jpashop.domain.item.Item;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
public class Category {
    @Id
    @GeneratedValue
    @Column(name = "category_id")
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(name = "category_item",
            joinColumns = @JoinColumn(name="category_id"),  // category_item 테이블에 있는 category_id
            inverseJoinColumns = @JoinColumn(name = "item_id")
    )
    private List<Item> items = new ArrayList<>();

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinTable(name = "parent_id")
    private Category parent;

    @OneToMany(mappedBy = "parent")
    private List<Category> child = new ArrayList<>();

    // 연관관계 메소드
    public void addChildCategory(Category child){
        this.child.add(child);
        child.setParent(parent);
    }
}

FK는 일대다 관계에서는 다에 둔다. 일대일 관계에서는 자주 사용하는 곳에 둔다. 연관 관계 주인은 FK가 위치한 클래스에서 연관 관계에 있는 멤버이다.

실무에서는 다대다를 절대 사용하지 말자.

엔티티 설계시 주의점

엔티티에는 가급적 Setter를 사용하지 말자.

모든 연관관계는 지연 로딩으로 설정하자.★

즉시로딩(EAGER)은 예측이 어렵고, 어떤 SQL이 실행될지 추적하기 어렵다. 특히 JPQL을 실행할 때 N+1 문제가 자주 발생한다.
실무에서 모든 연관관계는 지연로딩(LAZY)으로 설정해야 한다.
연관된 엔티티를 함께 DB에서 조회해야 하면, fetch join 또는 엔티티 그래프 기능을 사용한다.
@XToOne(OneToOne, ManyToOne) 관계는 기본이 즉시로딩이므로 직접 지연로딩으로 설정해야 한다.

컬렉션은 필드에서 초기화하자.

null 문제에서 안전하다.
하이버네이트는 엔티티를 영속화 할 때, 컬렉션을 감싸서 하이버네이트가 제공하는 내장 컬렉션으로 변경한다. 만약getOrders() 처럼 임의의 메서드에서 컬력션을 잘못 생성하면 하이버네이트 내부 메커니즘에 문제가 발생할 수 있다. 따라서 필드레벨에서 생성하는 것이 가장 안전하고, 코드도 간결하다.

cf) 영속화 = 자바 세상 밖(데이터베이스, 파일)에서도 유지하게 함.

테이블, 컬럼명 생성 전략(SpringPhysicalNamingStrategy)

스프링 부트 신규 설정 (엔티티(필드) -> 테이블(컬럼))
1. 카멜 케이스 언더스코어(memberPoint -> member_point)
2. .(점) -> _(언더스코어)
3. 대문자 -> 소문자

애플리케이션 구현 준비

구현 요구 사항

회원 기능
- 회원 등록
- 회원 조회 (전체, 이름으로 해당하는 사람들, ID로 개인)
상품 기능
- 상품 등록
- 상품 수정
- 상품 조회
주문 기능
- 상품 주문
- 주문 내역 조회
- 주문 취소

애플리케이션 아키텍쳐

회원 도메인 개발

회원 리포지토리 개발

package jpabook.jpashop.repository;

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jpabook.jpashop.domain.Member;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Repository
@RequiredArgsConstructor
@Transactional
public class MemberRepository {

    // @PersistenceContext // Spring이 EntityManager 주입
    private final EntityManager em;

    public void save(Member member){
        em.persist(member);
    }

    public Member findOne(Long id){
        return em.find(Member.class, id);	// em.find는 객체 반환
    }

    public List<Member> findByName(String name){
        return em.createQuery("select m from Member m where m.name = :name", Member.class)  // :name은 변수가 들어갈 자리
                .setParameter("name", name)
                .getResultList();
    }

    public List<Member> findAll(){
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }
}

회원 서비스 개발

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true) // JPA를 사용하는 곳에서는 Transactional 필수!!
public class MemberService {

    private final MemberRepository memberRepository;

    @Transactional  // readonly를 기본으로 설정하고, join만 write하므로 따로 설정
    public Long join(Member member){
        validateDuplicateMember(member);
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member){
        List<Member> findMembers = memberRepository.findByName(member.getName());
        if (!(findMembers.isEmpty())){
            throw new IllegalStateException("이미 존재하는 회원!");
        }
    }

    public List<Member> findMembers(){
        return memberRepository.findAll();
    }

    public Member findOne(Long memberId) {
        return memberRepository.findOne(memberId);
    }
}

회원 기능 테스트

package jpabook.jpashop.service;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.repository.MemberRepository;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(SpringExtension.class)
@SpringBootTest
@Transactional
class MemberServiceTest {

    MemberService memberService;
    MemberRepository memberRepository;

    @Autowired
    public MemberServiceTest(MemberService memberService, MemberRepository memberRepository) {
        this.memberService = memberService;
        this.memberRepository = memberRepository;
    }

    @Test
    public void 회원가입() throws Exception {
        //given
        Member member = new Member();
        member.setName("Peter");

        //when
        Long saveId = memberService.join(member);

        //then
        Assertions.assertThat(member).isEqualTo(memberRepository.findOne(saveId));
    }

    @Test
    public void 중복_회원_예외() throws Exception {
        //given
        Member member1 = new Member();
        Member member2 = new Member();
        member1.setName("Park");
        member2.setName("Park");

        //when
        memberService.join(member1);

        //then
        org.junit.jupiter.api.Assertions.assertThrows(IllegalStateException.class, () -> memberService.join(member2));
    }
}

상품 도메인 개발

상품 엔티티 개발

package jpabook.jpashop.domain.item;

import jakarta.persistence.*;
import jpabook.jpashop.domain.Category;
import jpabook.jpashop.exception.NotEnoughStockException;
import lombok.Getter;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)   // 테이블 하나에 다 저장할 것이라는 의미
@DiscriminatorColumn(name = "dtype")    // dtype이라는 행에 있는 값으로 구분할 것이라는 의미
@Getter
@Setter
public abstract class Item {    // 추상 클래스는 메소드가 구현되어 있지 않은 것. 구현체마다 다른 메소드 구현 가능

    @Id
    @GeneratedValue
    @Column(name = "item_id")
    private Long id;

    private String name;

    private int price;

    private int stockQuantity;

    @ManyToMany(mappedBy = "items")
    private List<Category> categories = new ArrayList<>();

    // 비즈니스 로직
    public void addStock(int quantity) {
        this.stockQuantity += quantity;
    }

    public void removeStock(int quantity) {
        int restStock = this.stockQuantity -= quantity;
        if (restStock < 0) {
            throw new NotEnoughStockException("재고가 부족합니다.");
        }
        this.stockQuantity = restStock;
    }
}

Item 밖에서 값을 계산해서 Setter를 통해 값을 갱신하기 보다는 Item 자체에 메소드를 구현하는 것이 바람직하다.

상품 리포지토리 개발

package jpabook.jpashop.repository;

import jakarta.persistence.EntityManager;
import jakarta.transaction.Transactional;
import jpabook.jpashop.domain.item.Item;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@Transactional
@RequiredArgsConstructor
public class ItemRepository {

    private final EntityManager em;

    public void save(Item item) {
        if (item.getId() == null){
            em.persist(item);
        }
        else{
            em.merge(item); // 업데이트와 비슷한 기능
        }

    }

    public Item findOne(Long id) {
        return em.find(Item.class, id);
    }

    public List<Item> findAll() {
        return em.createQuery("select i from Item i", Item.class).getResultList();
    }
}

상품 서비스 개발

package jpabook.jpashop.service;

import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.repository.ItemRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class ItemService {

    private final ItemRepository itemRepository;

    @Transactional
    public void saveItem(Item item) {
        itemRepository.save(item);
    }

    public List<Item> findItems(){
        return itemRepository.findAll();
    }

    public Item findOne(Long itemId){
        return itemRepository.findOne(itemId);
    }
}

주문 도메인 개발

주문 엔티티 개발

@Entity
@Table(name = "orders")
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)  // 생성자가 아니라 생성 메소드로 생성하게 함!!
public class Order {
	
    ...

    // 생성 메소드
    public static Order createOrder(Member member, Delivery delivery, OrderItem... orderItems){
        Order order = new Order();
        order.setMember(member);
        order.setDelivery(delivery);
        for (OrderItem orderItem : orderItems){
            order.addOrderItem(orderItem);
        }
        order.setStatus(OrderStatus.ORDER);
        order.setOrderDate(LocalDateTime.now());
        return order;
    }

    // 비즈니스 로직
    /*
    주문 취소
    */
    public void cancel() {
        if (delivery.getStatus() == DeliveryStatus.COMP){
            throw new IllegalStateException("이미 배송 완료된 상품은 취소 불가");
        }
        this.setStatus(OrderStatus.CANCEL);
        for (OrderItem orderItem : orderItems){
            orderItem.cancel(); // Item의 재고를 원상복구시킴
        }
    }

    // 조회 로직
    /*
    * 전체 주문 가격 조회
    * */
    public int getTotalPrice(){
        int totalPrice = 0;
        for (OrderItem orderItem : orderItems){
            totalPrice += orderItem.getTotalPrice();
        }
        return totalPrice;
    }
}

주문상품 엔티티 개발

package jpabook.jpashop.domain;

import jakarta.persistence.*;
import jpabook.jpashop.domain.item.Item;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)  // 생성자가 아니라 생성 메소드로 생성하게 함!!
public class OrderItem {

    @Id
    @GeneratedValue
    @Column(name = "order_item_id") // 테이블에 order_item_id 행에 저장
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "item_id")   // item_id 행과 연결
    private Item item;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")  // order_id 행과 연결
    private Order order;

    private int orderPrice;

    private int count;

    // 생성 메소드
    public static OrderItem createOrderItem(Item item, int orderPrice, int count){
        OrderItem orderItem = new OrderItem();
        orderItem.setItem(item);
        orderItem.setOrderPrice(orderPrice);
        orderItem.setCount(count);

        item.removeStock(count);
        return orderItem;
    }

    // 비즈니스 로직
    public void cancel(){
        getItem().addStock(count);
    }

    // 조회 로직
    public int getTotalPrice(){
        return getOrderPrice() * getCount();
    }
}

생성할 때, 밖에서 new 하고, Setter를 이용하는 것보다 public static 생성 메소드를 만드는 것이 좋다.

주문 리포지토리 개발

package jpabook.jpashop.repository;

import jakarta.persistence.EntityManager;
import jpabook.jpashop.domain.Order;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@RequiredArgsConstructor
public class OrderRepository {

    private final EntityManager em;

    public void save(Order order){
        em.persist(order);
    }

    public Order findOne(Long id) {
        return em.find(Order.class, id);
    }
}

주문 서비스 개발

package jpabook.jpashop.service;

import jpabook.jpashop.domain.*;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.repository.ItemRepository;
import jpabook.jpashop.repository.MemberRepository;
import jpabook.jpashop.repository.OrderRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderService {

    private final OrderRepository orderRepository;
    private final MemberRepository memberRepository;
    private final ItemRepository itemRepository;

    // 주문
    @Transactional
    public Long order(Long memberId, Long itemId, int count){   // 최소한의 정보만 받아서
        // 엔티티 조회
        Member member = memberRepository.findOne(memberId);
        Item item = itemRepository.findOne(itemId);

        // 배송정보 생성
        Delivery delivery = new Delivery();
        delivery.setAddress(member.getAddress());
        delivery.setStatus(DeliveryStatus.READY);

        // 주문상품 생성
        OrderItem orderItem = OrderItem.createOrderItem(item, item.getPrice(), count);

        // 주문 생성
        Order order = Order.createOrder(member, delivery, orderItem);

        // 주문 등록
        orderRepository.save(order);
        return order.getId();
    }

    // 주문 취소
    @Transactional
    public void cancelOrder(Long orderId){
        Order order = orderRepository.findOne(orderId);

        order.cancel();
    }

    // 주문 검색

}

Delivery와 OrderItem은 Order 도메인에서만 사용한다. 이렇게 사용 환경이 제한된 경우에만, cascade를 사용해야 한다.

cancelOrder에 @Transactional이 붙을 필요가 없지 않나? 라고 생각했었는데, 값을 변경하면, JPA가 데이터베이스를 알아서 변경하므로 @Transactional이 필요하다.

참고) 현재 주문 서비스의 주문과 주문 취소 메소드는 엔티티에 구현되어 있다. 서비스 계층은 엔티티의 메소드를 이용한다. 이처럼 엔티티가 비즈니스 로직을 가지고 객체 지향의 특성을 적극 활용하는 것을 도메인 모델 패턴이라고 한다. 반대로 엔티티에는 비즈니스 로직이 없고, 서비스 계층에서 비즈니스 로직을 처리하는 것을 트랜잭션 스크립트 패턴이라고 한다.

주문 기능 테스트

package jpabook.jpashop.service;

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.Order;
import jpabook.jpashop.domain.OrderStatus;
import jpabook.jpashop.domain.item.Book;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.exception.NotEnoughStockException;
import jpabook.jpashop.repository.OrderRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
@ExtendWith(SpringExtension.class)
@Transactional
class OrderServiceTest {

    private final OrderService orderService;
    private final OrderRepository orderRepository;
    private final EntityManager em;

    @Autowired
    public OrderServiceTest(OrderService orderService, OrderRepository orderRepository, EntityManager em) {
        this.orderService = orderService;
        this.orderRepository = orderRepository;
        this.em = em;
    }

    @Test
    public void 상품주문() {
        //given
        Member member = createMember();
        Item item = createBook("슬램덩크", 10000, 10);
        int orderCount = 3;

        //when
        Long orderId = orderService.order(member.getId(), item.getId(), orderCount);

        //then
        Order getOrder = orderRepository.findOne(orderId);

        Assertions.assertEquals(OrderStatus.ORDER, getOrder.getStatus());
        Assertions.assertEquals(1, getOrder.getOrderItems().size());
        Assertions.assertEquals(10000*3, getOrder.getTotalPrice());
        Assertions.assertEquals(7, item.getStockQuantity());
    }
    
    @Test
    public void 상품주문_재고수량초과() {
        //given
        Member member = createMember();
        Item item = createBook("슬램덩크", 10000, 1);
        int orderCount = 3;

        //when

        //then
        Assertions.assertThrows(NotEnoughStockException.class, ()->orderService.order(member.getId(), item.getId(), orderCount));
    }

    @Test
    public void 주문취소() {
        //given
        Member member = createMember();
        Item item = createBook("슬램덩크", 10000, 10);
        int orderCount = 3;

        Long orderId = orderService.order(member.getId(), item.getId(), orderCount);

        //when
        orderService.cancelOrder(orderId);

        //then
        Order getOrder = orderRepository.findOne(orderId);
        Assertions.assertEquals(getOrder.getStatus(), OrderStatus.CANCEL);
        Assertions.assertEquals(10, item.getStockQuantity());
    }

    private Member createMember(){
        Member member = new Member();
        member.setName("강대만");
        member.setAddress(new Address("서울", "산왕", "123-123"));
        em.persist(member);
        return member;
    }

    private Book createBook(String name, int price, int stockQuantity){
        Book book = new Book();
        book.setName(name);
        book.setStockQuantity(stockQuantity);
        book.setPrice(price);
        em.persist(book);
        return book;
    }
}

주문 검색 기능 개발

querydsl 배우고 작성

웹 계층 개발

홈 화면과 레이아웃

HomeController

package jpabook.jpashop.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@Slf4j  // 로그를 위한 애노테이션
public class HomeController {

    @RequestMapping("/")
    public String home(){
        log.info("home controller");
        return "home";
    }
}

home.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header">
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader" />
    <div class="jumbotron">
        <h1>HELLO SHOP</h1>
        <p class="lead">회원 기능</p>
        <p>
            <a class="btn btn-lg btn-secondary" href="/members/new">회원 가입</a>
            <a class="btn btn-lg btn-secondary" href="/members">회원 목록</a>
        </p>
        <p class="lead">상품 기능</p>
        <p>
            <a class="btn btn-lg btn-dark" href="/items/new">상품 등록</a>
            <a class="btn btn-lg btn-dark" href="/items">상품 목록</a>
        </p>
        <p class="lead">주문 기능</p>
        <p>
            <a class="btn btn-lg btn-info" href="/order">상품 주문</a>
            <a class="btn btn-lg btn-info" href="/orders">주문 내역</a>
        </p>
    </div>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

회원 등록

MemberForm

package jpabook.jpashop.controller;

import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class MemberForm {

    @NotEmpty(message = "회원 이름은 필수")
    private String name;

    private String city;

    private String street;

    private String zipcode;
}

Member로 전달해도 되긴 되지만, Form과 정확하게 맞지 않고, @NotEmpty 같은 추가 기능을 넣으면 복잡해지기 때문에 MemberForm을 새로 만드는 것이 좋다.

MemberController

package jpabook.jpashop.controller;

import jakarta.validation.Valid;
import jpabook.jpashop.domain.Address;
import jpabook.jpashop.domain.Member;
import jpabook.jpashop.service.MemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
@RequiredArgsConstructor
public class MemberController {

    private final MemberService memberService;

    @GetMapping("/members/new")
    public String createForm(Model model){
        model.addAttribute("memberForm", new MemberForm()); // MemberForm을 만들어서 전달
        return "members/createMemberForm";
    }

    @PostMapping("/members/new")
    public String create(@Valid MemberForm form, BindingResult result){   // @NotEmpty 검증, 결과를 모두 result 변수에 저장, MemberForm과 result를 return에 가서 쓸 수 있도록 도와줌
        if (result.hasErrors()){
            return "/members/createMemberForm";
        }

        Address address = new Address(form.getCity(), form.getStreet(), form.getZipcode());

        Member member = new Member();
        member.setName(form.getName());
        member.setAddress(address);

        Long memberId = memberService.join(member);
        return "redirect:/";
    }
}

회원 가입을 누르면, /members/new로 GET Request를 보낸다. 그러면 MemberForm과 함께 회원 가입 페이지를 띄운다.

회원 가입 페이지에서 POST Request를 보내면, MemberForm에 반영되어 전달받는다. @Valid는 @NotEmpty이어야 하는 이름을 검증하며, BindingResult를 통해 오류 같은 결과를 result에 저장한다. 이것들은 return 하는 곳에 같이 보낸다.

Member 목록 조회

MemberController

@Controller
@RequiredArgsConstructor
public class MemberController {
	...
    
    @GetMapping("/members")
    public String list(Model model){
        List<Member> members = memberService.findMembers();
        model.addAttribute("members", members);
        return "members/memberList";
    }
}

memberList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader" />
    <div>
        <table class="table table-striped">
            <thead>
            <tr>
                <th>#</th>
                <th>이름</th>
                <th>도시</th>
                <th>주소</th>
                <th>우편번호</th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="member : ${members}">
                <td th:text="${member.id}"></td>
                <td th:text="${member.name}"></td>
                <td th:text="${member.address?.city}"></td>	// ?는 null이면 진행하지 않는다는 의미
                <td th:text="${member.address?.street}"></td>
                <td th:text="${member.address?.zipcode}"></td>
            </tr>
            </tbody>
        </table>
    </div>
    <div th:replace="fragments/footer :: footer" />
</div> <!-- /container -->
</body>
</html>

상품 등록

ItemController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.item.Book;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Controller
@RequiredArgsConstructor
public class ItemController {
    private final ItemService itemService;

    @GetMapping("/items/new")
    public String newItem(Model model){
        BookForm bookForm = new BookForm();
        model.addAttribute("form", bookForm);
        return "items/createItemForm";
    }

    @PostMapping("/items/new")
    public String create(BookForm bookForm){
        Book book = Book.setFromForm(bookForm);

        itemService.saveItem(book);
        return "redirect:/";
    }
}

Setter는 최대한 자제하고, 엔티티에 메소드를 만들어 사용하는 것이 좋다.

Book (생성 메소드 추가)

package jpabook.jpashop.domain.item;

import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import jpabook.jpashop.controller.BookForm;
import lombok.Getter;
import lombok.Setter;

@Entity
@DiscriminatorValue("B")
@Getter
@Setter
public class Book extends Item {
    private String author;
    private String isbn;

    public static Book setFromForm(BookForm bookForm){
        Book book = new Book();
        book.setPrice(bookForm.getPrice());
        book.setName(bookForm.getName());
        book.setStockQuantity(bookForm.getStockQuantity());
        book.setId(bookForm.getId());
        book.setIsbn(bookForm.getIsbn());
        book.setAuthor(bookForm.getAuthor());
        return book;
    }
}

상품 목록

@Controller
@RequiredArgsConstructor
public class ItemController {
    ...
    
    @GetMapping("/items")
    public String list(Model model){
        List<Item> items = itemService.findItems();
        model.addAttribute("items", items);
        return "items/itemList";
    }
}

itemList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header" />
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader"/>
    <div>
        <table class="table table-striped">
            <thead>
            <tr>
                <th>#</th>
                <th>상품명</th>
                <th>가격</th>
                <th>재고수량</th>
                <th></th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="item : ${items}">
                <td th:text="${item.id}"></td>
                <td th:text="${item.name}"></td>
                <td th:text="${item.price}"></td>
                <td th:text="${item.stockQuantity}"></td>
                <td>
                    <a href="#" th:href="@{/items/{id}/edit (id=${item.id})}"
                       class="btn btn-primary" role="button">수정</a>
                </td>
            </tr>
            </tbody>
        </table>
    </div>
    <div th:replace="fragments/footer :: footer"/>
</div> <!-- /container -->
</body>
</html>

상품 수정

ItemController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.item.Book;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Controller
@RequiredArgsConstructor
public class ItemController {
    private final ItemService itemService;

    @GetMapping("/items/new")
    public String newItem(Model model){
        BookForm bookForm = new BookForm();
        model.addAttribute("form", bookForm);
        return "items/createItemForm";
    }

    @PostMapping("/items/new")
    public String create(BookForm bookForm){
        Book book = Book.setFromForm(bookForm);

        itemService.saveItem(book);
        return "redirect:/";
    }

    @GetMapping("/items")
    public String list(Model model){
        List<Item> items = itemService.findItems();
        model.addAttribute("items", items);
        return "items/itemList";
    }

    @GetMapping("/items/{itemId}/edit")
    public String updateItemForm(@PathVariable("itemId") Long itemId, Model model){
        Book item = (Book)itemService.findOne(itemId);

        BookForm form = new BookForm();
        form.setId(item.getId());
        form.setName(item.getName());
        form.setPrice(item.getPrice());
        form.setStockQuantity(item.getStockQuantity());
        form.setAuthor(item.getAuthor());
        form.setIsbn(item.getIsbn());

        model.addAttribute("form", form);
        return "items/updateItemForm";
    }

    @PostMapping("items/{itemId}/edit")
    public String updateItem(@ModelAttribute("form") BookForm form){    // form으로 전달받은 Model Attribute를 가져옴. 없어도 됨.
        Book book = Book.setFromForm(form);

        itemService.saveItem(book);
        return "redirect:/items";
    }
}

createItemForm과 updateItemForm은 별 차이가 없다. 상품을 등록(create)할 때는 값이 지정되지 않은 새로운 Form을 만들어서 전달하므로 입력 칸들이 비어있지만, 상품을 수정(update)할 때는 id로부터 Book을 찾고, 그 정보를 Form에 반영하여 전달하므로 입력 칸들이 채워져 있다.

변경 감지와 병합 ★★★★★

준영속 엔티티

데이터베이스에 갔다와서 id가 이미 존재하는 객체를 말한다. 새로 객체를 만들고 id를 부여해도 준영속 엔티티로 간주한다. 준영속 엔티티는 영속성 컨텍스트가 더는 관리하지 않는다. 즉, 변경이 일어나도 데이터베이스에 반영되지 않는다.

준영속 엔티티를 수정하는 2가지 방법

변경 감지 기능 사용
병합 사용

변경 감지 기능 = 더티 체킹

@Transactional
void update(Item itemParam) { //itemParam: 파라미터로 넘어온 준영속 상태의 엔티티
	Item findItem = em.find(Item.class, itemParam.getId()); // 같은 영속성 엔티티를 조회
	findItem.setPrice(itemParam.getPrice()); // 영속성 엔티티의 데이터를 수정하므로 데이터베이스에 반영됨
}

(예시)

@Transactional
public Item updateItem(Long itemId, Book param){
    Item findItem = itemRepository.findOne(itemId);
    findItem.setPrice(param.getPrice());
    findItem.setName(param.getName());
    findItem.setStockQuantity(param.getStockQuantity());
    return findItem;
}

병합 사용

병합은 준영속 상태의 엔티티를 영속 상태의 엔티티로 변경한다.

@Transactional
void update(Item itemParam) { //itemParam: 파라미터로 넘어온 준영속 상태의 엔티티
	Item mergeItem = em.merge(itemParam);
}

itemParam이 전달되면, EntityManager가 데이터베이스에서 itemParam과 같은 id를 가지는 것을 찾아 모두 itemParam과 같게 만든다.

변경 감지와 달리 병합은 모든 필드를 모두 업데이트하기 때문에 위험하다. 그래서 입력값이 전달되지 않았을 경우, null로 변경될 수 있다. 따라서 병합은 자제하고, 변경 감지를 사용하자.

엔티티를 변경할 때는 항상 변경 감지를 사용 권장

컨트롤러에서 어설프게 엔티티 생성 금지
트랜잭션이 있는 서비스 계층에 식별자(id)와 변경할 데이터를 명확하게 전달(파라미터 or dto)
트랜잭션이 있는 서비스 계층에서 영속 상태의 엔티티를 조회하고, 엔티티의 데이터를 직접 변경
트랜잭션 커밋 시점에 변경 감지가 실행

ItemService

@Service
@Transactional(readOnly = true)
@RequiredArgsConstructor
public class ItemService {

    ...

    @Transactional
    public Item updateItem(Long itemId, String name, int price, int stockQuantity){
        Item findItem = itemRepository.findOne(itemId);
        findItem.setName(name);
        findItem.setPrice(price);
        findItem.setStockQuantity(stockQuantity);
        return findItem;
    }
}

ItemController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.item.Book;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.repository.ItemRepository;
import jpabook.jpashop.service.ItemService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Controller
@RequiredArgsConstructor
public class ItemController {
    private final ItemService itemService;
    private final ItemRepository itemRepository;

    @GetMapping("/items/new")
    public String newItem(Model model){
        BookForm bookForm = new BookForm();
        model.addAttribute("form", bookForm);
        return "items/createItemForm";
    }

    @PostMapping("/items/new")
    public String create(BookForm bookForm){
        Book book = Book.setFromForm(bookForm);

        itemService.saveItem(book);
        return "redirect:/";
    }

    @GetMapping("/items")
    public String list(Model model){
        List<Item> items = itemService.findItems();
        model.addAttribute("items", items);
        return "items/itemList";
    }

    @GetMapping("/items/{itemId}/edit")
    public String updateItemForm(@PathVariable("itemId") Long itemId, Model model){
        Book item = (Book)itemService.findOne(itemId);

        BookForm form = new BookForm();
        form.setId(item.getId());
        form.setName(item.getName());
        form.setPrice(item.getPrice());
        form.setStockQuantity(item.getStockQuantity());
        form.setAuthor(item.getAuthor());
        form.setIsbn(item.getIsbn());

        model.addAttribute("form", form);
        return "items/updateItemForm";
    }

    @PostMapping("items/{itemId}/edit")
    public String updateItem(@PathVariable("itemId") Long itemId, @ModelAttribute("form") BookForm form){    // form으로 전달받은 Model Attribute를 가져옴. 없어도 됨.
        itemService.updateItem(form.getId(), form.getName(), form.getPrice(), form.getStockQuantity());
        return "redirect:/items";
    }
}

상품 주문

OrderController

package jpabook.jpashop.controller;

import jpabook.jpashop.domain.Member;
import jpabook.jpashop.domain.item.Item;
import jpabook.jpashop.service.ItemService;
import jpabook.jpashop.service.MemberService;
import jpabook.jpashop.service.OrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;

@Controller
@RequiredArgsConstructor
public class OrderController {

    private final OrderService orderService;
    private final MemberService memberService;
    private final ItemService itemService;

    @GetMapping("/order")
    public String createForm(Model model){
        List<Member> members = memberService.findMembers();
        List<Item> items = itemService.findItems();

        model.addAttribute("members", members);
        model.addAttribute("items", items);

        return "/order/orderForm";
    }

    @PostMapping("/order")
    public String order(@RequestParam("memberId") Long memberId, @RequestParam("itemId") Long itemId, @RequestParam("count") int count){
        Long orderId = orderService.order(memberId, itemId, count);
        return "redirect:/orders";
    }
}

주문 목록 검색

@Controller
@RequiredArgsConstructor
public class OrderController {

	...

    @GetMapping("/orders")
    public String orderList(@ModelAttribute("orderSearch") OrderSearch orderSearch, Model model){
        List<Order> orders = orderService.findOrders(orderSearch);

        model.addAttribute("orders", orders);

        return "order/orderList";
    }
}

orderList.html

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/header :: header"/>
<body>
<div class="container">
    <div th:replace="fragments/bodyHeader :: bodyHeader"/>
    <div>
        <div>
            <form th:object="${orderSearch}" class="form-inline">
                <div class="form-group mb-2">
                    <input type="text" th:field="*{memberName}" class="formcontrol"
                           placeholder="회원명"/>
                </div>
                <div class="form-group mx-sm-1 mb-2">
                    <select th:field="*{orderStatus}" class="form-control">
                        <option value="">주문상태</option>
                        <option th:each=
                                        "status : ${T(jpabook.jpashop.domain.OrderStatus).values()}"
                                th:value="${status}"
                                th:text="${status}">option
                        </option>
                    </select>
                </div>
                <button type="submit" class="btn btn-primary mb-2">검색</button>
            </form>
        </div>
        <table class="table table-striped">
            <thead>
            <tr>
                <th>#</th>
                <th>회원명</th>
                <th>대표상품 이름</th>
                <th>대표상품 주문가격</th>
                <th>대표상품 주문수량</th>
                <th>상태</th>
                <th>일시</th>
                <th></th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="item : ${orders}">
                <td th:text="${item.id}"></td>
                <td th:text="${item.member.name}"></td>
                <td th:text="${item.orderItems[0].item.name}"></td>
                <td th:text="${item.orderItems[0].orderPrice}"></td>
                <td th:text="${item.orderItems[0].count}"></td>
                <td th:text="${item.status}"></td>
                <td th:text="${item.orderDate}"></td>
                <td>
                    <a th:if="${item.status.name() == 'ORDER'}" href="#"
                       th:href="'javascript:cancel('+${item.id}+')'"
                       class="btn btn-danger">CANCEL</a>
                </td>
            </tr>
            </tbody>
        </table>
    </div>
    <div th:replace="fragments/footer :: footer"/>
</div> <!-- /container -->
</body>
<script>
    function cancel(id) {
        var form = document.createElement("form");
        form.setAttribute("method", "post");
        form.setAttribute("action", "/orders/" + id + "/cancel");
        document.body.appendChild(form);
        form.submit();
    }
</script>
</html>

Form Method의 default는 GET이므로, GET Mapping에 해당하는 것이 실행된다.

OrderSearch (검색 기준)

package hades.self.form;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class OrderSearch {
    private String memberName;
    private String orderStatus;
}

주문 취소

@Controller
@RequiredArgsConstructor
public class OrderController {

    ...

    @PostMapping("/orders/{orderId}/cancel")
    public String cancel(@PathVariable("orderId") Long orderId){
        orderService.cancelOrder(orderId);
        return "redirect:/orders";
    }
}

기억하면 좋을 것

@Id는 데이터베이스를 거쳐서 id를 부여하게 한다.
메소드를 호출할 때, 되도록이면 id를 넘기는 것이 좋지만, 너무 얽메이지 말 것.
클래스 내부에서 this.멤버변수 = 변경값으로 하던지 Setter를 이용하던지 너무 얽메이지 말 것.
영속성 객체의 필드값을 변경하면, 데이터베이스에서도 변경 내용이 반영된다. 영속성 객체의 필드값을 변경했는데, 반영되지 않았다면, @Transactional(readonly=true)인 것은 아닌지 확인할 것.
Model은 주기도 가능하지만, 받기도 가능함.(추정)

'🏃🏻‍♂️ 기본훈련 > Spring' 카테고리의 다른 글

[Thymeleaf] 텍스트 리터럴 (0)	2024.08.05
[Thymeleaf] 템플릿 위치 (0)	2024.07.29
[Spring] 같은 클래스의 빈이 두 개 이상일 때 (0)	2024.07.25
[Spring] 스프링 기초 (2) (0)	2024.07.24
[Spring] 스프링 기초 (1) (0)	2024.07.22

'🏃🏻‍♂️ 기본훈련/Spring' Related Articles

hades

[Spring] 스프링 기초 (3) 본문

[Spring] 스프링 기초 (3)

프로젝트 환경설정

도메인 분석 설계

요구사항 분석

도메인 모델과 테이블 설계

엔티티 클래스 개발

엔티티 설계시 주의점

애플리케이션 구현 준비

구현 요구 사항

애플리케이션 아키텍쳐

회원 도메인 개발

회원 리포지토리 개발

회원 서비스 개발

회원 기능 테스트

상품 도메인 개발

상품 엔티티 개발

상품 리포지토리 개발

상품 서비스 개발

주문 도메인 개발

주문 엔티티 개발

주문상품 엔티티 개발

주문 리포지토리 개발

주문 서비스 개발

주문 기능 테스트

주문 검색 기능 개발

웹 계층 개발

홈 화면과 레이아웃

회원 등록

Member 목록 조회

상품 등록

상품 목록

상품 수정

변경 감지와 병합 ★★★★★

상품 주문

주문 목록 검색

주문 취소

기억하면 좋을 것

'🏃🏻‍♂️ 기본훈련 > Spring' 카테고리의 다른 글

티스토리툴바