์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- ํด์
- matlab
- OS
- ๋ฐฑ์ค
- ํ๋ก๊ทธ๋๋จธ์ค
- ๋งคํธ๋ฉ
- BFS
- spring
- ์ด์์ฒด์
- ์ ๋ ๋์
- ToyProject
- ์ด์งํ์
- python
- ํด์๋ฒ
- ์นด์นด์ค๊ธฐ์ถ
- Java
- JPA
- webcrawling
- ํ์ด์ฌ
- ๊ทธ๋ฆฌ๋
- selenium
- ์ผ์ฑ๊ธฐ์ถ
- ๋จ์ํ ์คํธ
- API
- Crawling
- ์นด์นด์ค
- ์นํฌ๋กค๋ง
- ์์์ฒ๋ฆฌ
- ์๊ณ ๋ฆฌ์ฆ
- ํฌ๋กค๋ง
DevKim
[02] ์ฃผ๋ฌธ ๋๋ฉ์ธ ๊ฐ๋ฐ ๋ณธ๋ฌธ
๐ ๊ตฌํ ๊ธฐ๋ฅ ๐
- ์ํ ์ฃผ๋ฌธ
- ์ฃผ๋ฌธ ๋ด์ญ ์กฐํ
- ์ฃผ๋ฌธ ์ทจ์
[ ์ฃผ๋ฌธ ๋๋ฉ์ธ ์์ฑ ๋ฉ์๋ ์ถ๊ฐ ]
๋น์ฆ๋์ค ๋ก์ง์ด ๊ฐ์ฅ ๋ณต์กํ ์ฃผ๋ฌธ ๋๋ฉ์ธ ๋ถ๋ถ์ด๋ค.
๐ 01. ์ฃผ๋ฌธ ์์ฑ ๋ฉ์๋ ๋ง๋ค๊ธฐ
์์ฑ์๋ก ์์ฑํ ์๋ ์์ง๋ง, ์ ์ ํฉํ ๋ฆฌ ๋ฉ์๋๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ ๋ ํจ๊ณผ์ ์ผ๋ก ์ฝ๋๋ฅผ ์งค ์ ์๋ค.
์ ์ ํฉํ ๋ฆฌ๋ ๊ทธ ์ ๋ช ํ ์ดํํฐ๋ธ ์๋ฐ ์ฒซ์ฅ์ ๋์ค๋ ์ด์ผ๊ธฐ์ด๋ค. ์์ธํ๊ฑด ๋ค์์ ์ ๋ฆฌ๋ฅผ ํด๋ด์ผ๊ฒ ๋ค.
๋๋ฉ์ธ ์ฃผ๋ ๊ฐ๋ฐ์ผ๋ก ์ค์ต์ ์งํํ๊ณ ์๊ธฐ์,
ํด๋น ๋ฐ์ดํฐ๊ฐ ์๋ ๋ถ๋ถ์์ ๋น์ฆ๋์ค ๋ก์ง์ ํด๊ฒฐํ๋ค.
@Entity
@Getter
@Setter
@Table(name = "orders")
public class Order {
@Id
@GeneratedValue
@Column(name = "order_id")
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "member_id")
private Member member;
@OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
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) //์ฃผ๋ฌธ ์ํ [ORDER,CANCEL]
private OderStatus 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);
}
/**
* ์ฃผ๋ฌธ ์์ฑ ๋ฉ์๋
* todo : ์ฃผ๋ฌธ ํ์, ๋ฐฐ์ก ์ ๋ณด, ์ํ๋ช
์ ์
๋ ฅํ์ฌ ์ฃผ๋ฌธ ์์ฑ
*/
public static Order createOrder(Member member, Delivery delivery, OrderItem... orderItems) {
Order order = new Order();
order.setMember(member);
order.setDelivery(delivery);
for (OrderItem item : orderItems) {
order.addOrderItem(item);
}
order.setStatus(OderStatus.ORDER);
order.setOrderDate(LocalDateTime.now());
return order;
}
...
}
Setter๋ ์ฌ์ค์ ๋นผ์ค์ผํ๊ณ , ๋ฐ์ดํฐ๋ Setter๋ก ๋ฐ๋ก ๋ฐ๊พธ๋ฉด ์๋์ง๋ง.. ์ฐ์ต์ด๋๊น..ใ ใ
์ฃผ๋ฌธํ์,๋ฐฐ์ก์ ๋ณด, ์ํ๋ช ์ ์ ๋ ฅํ์ฌ ์ฃผ๋ฌธ์ ์์ฑํด์ฃผ์๋ค.
[ ์ฃผ๋ฌธ ๋๋ฉ์ธ ๋น์ฆ๋์ค ๋ก์ง ์ถ๊ฐ ]
๐ 1. ๋น์ฆ๋์ค ๋ก์ง
- ์ฃผ๋ฌธ์ด ์ทจ์ ๋์์ ๋ -> ์ฌ๊ณ ์๋ ์ฆ๊ฐํด์ผํจ
- ๋ฐฐ์ก ์ํ๊ฐ ์ด๋ฏธ ๋ฐฐ์ก์ค์ด๋ผ๋ฉด, ์ทจ์๋ ๋ถ๊ฐ๋ฅํ๋ค๋ ์์ธ ์ฒ๋ฆฌ๋ฅผ ์งํ
- ๊ทธ๊ฒ ์๋๋ผ๋ฉด ์ทจ์ ์ํ๋ก ๋ฐ๊ฟ์ฃผ๊ณ , orderItem ์ชฝ์ cancel ๋ฉ์๋๋ฅผ ์์ฑํ์ฌ ์ฌ๊ณ ์๋์ ์ฆ๊ฐ์์ผ์ค๋ค.
๐ 2. ์กฐํ ๋ก์ง
- ์ ์ฒด ์ฃผ๋ฌธ ๊ฐ๊ฒฉ ์กฐํํ๊ธฐ
@Entity
@Getter
@Setter
@Table(name = "orders")
public class Order {
...
/**
* ๋น์ฆ๋์ค ๋ก์ง
* todo : ์ฃผ๋ฌธ ์ทจ์ -> ์ฌ๊ณ ์๋ ์ฆ๊ฐ
*/
public void cancel(Order order) {
//์ด๋ฏธ ๋ฐฐ์ก์๋ฃ
if (delivery.getStatus() == DeliveryStatus.COMP) {
throw new IllegalStateException("์ด๋ฏธ ๋ฐฐ์ก์๋ฃ๋ ์ํ์ ์ทจ์ํ ์ ์์ต๋๋ค.");
}
this.setStatus(OderStatus.CANCEL);
for (OrderItem orderItem : orderItems) {
orderItem.cancel();
}
}
/**
* ์กฐํ ๋ก์ง
* todo : ์ ์ฒด ์ฃผ๋ฌธ ๊ฐ๊ฒฉ ์กฐํ
*/
public int getTotalPrice() {
int totalPrice = 0;
for (OrderItem orderItem : orderItems) {
totalPrice += orderItem.getTotalPrice();
}
return totalPrice;
}
//==stream,lambda ์ฌ์ฉ์==//
//public int getTotalPrice() {
// int totalPrice = orderItems.stream()
// .mapToInt(OrderItem::getTotalPrice)
// .sum();
// return totalPrice;
// }
}
/**
* ๋น์ค๋์ค ๋ก์ง
* todo: ์ฃผ๋ฌธ ์ทจ์์ ์ฃผ๋ฌธ ์๋๋งํผ ์ฌ๊ณ ๋๋ฆฌ๊ธฐ
*/
public void cancel() {
this.getItem().addStock(count);
}
์ด๊ฒ๋ํ orderItem์ ์๋ ํ์ฌ ์ ํ์ ๊ฐ๊ฒฉ๊ณผ ์ฃผ๋ฌธ ์๋์ ๊ณฑํด์ ๊ฐ์ ธ์จ๋ค.
/**
* todo : ์ ์ฒด ๊ฐ๊ฒฉ
*/
public int getTotalPrice() {
return orderPrice*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;
}
[ ์ฃผ๋ฌธ Repository ]
์ฃผ๋ฌธ์๋ ํ์์ ๋ฐ๋ฅธ ์ฃผ๋ฌธ ์ํ์ ์ฃผ๋ฌธ ์ํ์ ๋ฐ๋ผ ๊ฒ์ํ ์ ์๋ ๊ฒ์ ๊ธฐ๋ฅ์ ๊ฐ์ง๋ ๋ถ๋ถ์ด์ด์
๋์ ์ฟผ๋ฆฌ๋ฅผ ์ฌ์ฉํด์ผํ๋ค. ๋์ ์ฟผ๋ฆฌ๋ ์ผ๋จ JPA Criteria๋ก ์์ฑ๋ ์ฝ๋๋ก ๋๊ณ ,
Querydsl๋ก ๋ณ๊ฒฝํ๋ ๋ถ๋ถ์ todo๋ก ๋จ๊ฒจ๋๋ค.
@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);
}
/**
* todo: ์ฃผ๋ฌธ ๊ฒ์ ๊ธฐ๋ฅ (๋์ ์ฟผ๋ฆฌ)
*/
}
[ ์ฃผ๋ฌธ Service ]
๐ 01. ์ฃผ๋ฌธํ๊ธฐ
Step 1. ์ฃผ๋ฌธํ member๊ฐ ๋๊ตฐ์ง ์กฐํ
Step 2. ๋ฐฐ์ก ์ ๋ณด ์์ฑ (์ํ๋ ๋ณ๊ฒฝ)
Step 3. ์ฃผ๋ฌธํ ์ํ ์์ฑ (์ฌ๋ฌ๊ฐ)
Step 4. ์ฃผ๋ฌธ ์์ฑ
Step 5. ์ฃผ๋ฌธ ์ ์ฅ
@RequiredArgsConstructor
@Service
@Transactional
public class OrderService {
private final MemberRepository memberRepository;
private final ItemRepository itemRepository;
private final OrderRepository orderRepository;
/**
* todo : ์ฃผ๋ฌธํ๊ธฐ
* input : ์ฃผ๋ฌธํ memberId, ์ฃผ๋ฌธํ ์ํ, ์ํ ๊ฐฏ์
* 1. ์ฃผ๋ฌธํ member๊ฐ ๋๊ตฐ์ง ์กฐํ
* 2. ๋ฐฐ์ก ์ ๋ณด ์์ฑ
* 3. ์ฃผ๋ฌธํ ์ํ์์ฑ (์ฌ๋ฌ๊ฐ)
* 4. ์ฃผ๋ฌธ ์์ฑ
* 5. ์ฃผ๋ฌธ ์ ์ฅ
*/
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();
}
...
}
์ด๋, ์ฃผ๋ฌธ๊ณผ ์ฃผ๋ฌธ์ํ์ ์์ฑ ๋ฉ์๋๋ฅผ ๋ฐ๋ก ๋ง๋ค์ด๋จ๊ธฐ ๋๋ฌธ์
๋ฐ์์ ๋๊ฐ new๋ก ์์ฑํ์ง ์๋๋ก ์ฃผ๋ฌธ๊ณผ ์ฃผ๋ฌธ์ํ์ ๊ธฐ๋ณธ์์ฑ์๋ฅผ protected ๋ก ์ถ๊ฐ๋ก ์ค์ ํด์ฃผ์๋ค.
๐02. ์ฃผ๋ฌธ ์ทจ์
step 1. ์ทจ์๋ฅผ ๋ฃ์ ํด๋น ์ฃผ๋ฌธ ์ฐพ๊ธฐ
step 2. ์ฃผ๋ฌธ์ทจ์์ ๋ฐ๋ฅธ ์ฌ๊ณ ์๋ ์ฆ๊ฐ
/**
* todo : ์ฃผ๋ฌธ ์ทจ์
* Input : ์ทจ์ํ ์ฃผ๋ฌธ id
*/
public void CancelOrder(Long OrderId)
{
Order order = orderRepository.findOne(OrderId);
order.cancel();
}
๐03. ์ฃผ๋ฌธ ๊ฒ์
//Querydsl๋ก ๋ฆฌํฉํ ๋ง ์์
์ฝ๋๋ฅผ ๋ณด๋ฉด ๋น์ฆ๋์ค ๋ก์ง์ด ๋๋ถ๋ถ ์ํฐํฐ์ ์๋ค.
์๋น์ค ๊ณ์ธต์ ๋จ์ํ ํ์ํ ์ญํ ๋ค์ ์ฐ๊ฒฐํ๋ ์ญํ ๋งํ๋ค.
JPA๊ฐ์ ORM์ ์ฌ์ฉํ ๋์๋ ๋๋ฉ์ธ ๋ชจ๋ธ ํจํด์ ์ฌ์ฉํ๋๊ฒ ์ผ๋ฐ์ ์ด๋ผ๊ณ ํ๋ค.
<-> ํธ๋์ญ์ ์คํฌ๋ฆฝํธ ํจํด (์ด๊ฒ ๋ ์ ์ง๋ณด์ํ๋๋ฐ ์ข์ ๋๋ ์์)
[ ์ฃผ๋ฌธ ๊ธฐ๋ฅ ํ ์คํธ ]
- ์ํ ์ฃผ๋ฌธ ์ฑ๊ณต์ฌ๋ถ
- ์ฃผ๋ฌธ ์ทจ์ ์ฑ๊ณต์ฌ๋ถ
- ์ํ์ ์ฃผ๋ฌธํ ๋ ์ฌ๊ณ ์๋์ ์ด๊ณผํ๋ฉด ์๋จ
๐ 01. ์ํ ์ฃผ๋ฌธ ์ฑ๊ณต์ฌ๋ถ
- ์ฃผ๋ฌธ ํ ์ฃผ๋ฌธ์ํ๊ฐ ORDER๋ก ๋ณ๊ฒฝ๋์๋์ง
- ์ฃผ๋ฌธํ ์ํ์ ์ข ๋ฅ์ ์ ํ์ธ
- ์ฃผ๋ฌธ ๊ฐ๊ฒฉ = ์ฃผ๋ฌธ ์๋*์ฃผ๋ฌธ ๊ฐ๊ฒฉ์ธ์ง
- ์ฃผ๋ฌธ ์๋๋งํผ ์ฌ๊ณ ๊ฐ์ํ๋์ง
/**
* todo: ์ํ ์ฃผ๋ฌธํ๊ธฐ ์ฑ๊ณต์ฌ๋ถ
* member,Item,Count
*/
@Test
public void ์ํ_์ฃผ๋ฌธํ๊ธฐ() throws Exception{
//given
//๋ฉค๋ฒ ์์ฑ
Member member=createMember();
//์ํ ์์ฑ
Item item=createItem();
// ์ฃผ๋ฌธํ ์ํ ๊ฐฏ์
int count=2;
//when
// ์ฃผ๋ฌธ์์ฑ
Long OrderId = orderService.Order(member.getId(), item.getId(), count);
//then
Order order=orderRepository.findOne(OrderId);
/**
* ์ฃผ๋ฌธ ์ํ :ORDER
* ์ฃผ๋ฌธํ ์ํ ์ข
๋ฅ์ ์ :1
* ์ฃผ๋ฌธ ๊ฐ๊ฒฉ = ์ฃผ๋ฌธ์๋*์ฃผ๋ฌธ ๊ฐ๊ฒฉ
* ์ฃผ๋ฌธ ์๋๋งํผ ์ฌ๊ณ ๊ฐ์
*/
assertEquals("์ฃผ๋ฌธ ์ํ๋ Status", OrderStatus.ORDER,order.getStatus());
assertEquals("์ฃผ๋ฌธ ์ํ ์ข
๋ฅ์ ์๋ 1๊ฐ",1,order.getOrderItems().size());
assertEquals("์ฃผ๋ฌธ ๊ฐ๊ฒฉ์ ์ฃผ๋ฌธ์๋*์ฃผ๋ฌธ๊ฐ๊ฒฉ",2*10000,order.getTotalPrice());
assertEquals("์ฃผ๋ฌธ ์๋๋งํผ ์ฌ๊ณ ๊ฐ์",98,item.getStockQuantity());
}
๐02. ์ฃผ๋ฌธ์ทจ์ ์ฑ๊ณต์ฌ๋ถ
- ์ฃผ๋ฌธ ์ทจ์์ ์ํ๋ CANCEL
- ์ฃผ๋ฌธ ์ทจ์์ ์ฌ๊ณ ์๋ ์ฆ๊ฐ
@Test
public void ์ฃผ๋ฌธ์ทจ์() throws Exception{
//given
//๋ฉค๋ฒ ์์ฑ
Member member=createMember();
//์ํ ์์ฑ
Item item=createItem();
// ์ฃผ๋ฌธํ ์ํ ๊ฐฏ์
int count=2;
// ์ฃผ๋ฌธ์์ฑ
Long OrderId = orderService.Order(member.getId(), item.getId(), count);
//when
orderService.CancelOrder(OrderId);
//then
/**
* ์ฃผ๋ฌธ ์ทจ์์ ์ํ๋ CANCEL
* ์ฃผ๋ฌธ ์ทจ์์ ์ฌ๊ณ ์๋ ์ฆ๊ฐ
*/
Order order =orderRepository.findOne(OrderId);
assertEquals("์ฃผ๋ฌธ ์ทจ์์ ์ํ๋ CANCEL",OrderStatus.CANCEL,order.getStatus());
assertEquals("์ฃผ๋ฌธ ์ทจ์์ ์ทจ์๋ ์ํ์ ์ฌ๊ณ ๋ ์ฆ๊ฐ",100,item.getStockQuantity());
}
๐03. ์ฌ๊ณ ๋ณด๋ค ๋ ๋ง์ด ์ฃผ๋ฌธํ์ ๋
- ์์๋๋ก ์ด์ ์ ์์ฑํด๋ NotEnoughStockException์ด ํฐ์ ธ์ผํ๋ค.
@Test(expected = NotEnoughStockException.class)
public void ์ํ์ฃผ๋ฌธ_์ฌ๊ณ ์๋์ด๊ณผ() throws Exception{
//given
//๋ฉค๋ฒ ์์ฑ
Member member=createMember();
//์ํ ์์ฑ
Item item=createItem();
// ์ด๊ณผ๋ก ์ํ ์ฃผ๋ฌธ
int count=101;
//when
// ์ฃผ๋ฌธ์์ฑ
Long OrderId = orderService.Order(member.getId(), item.getId(), count);
//then
fail("์ฌ๊ณ ์๋ ์์ธ๊ฐ ๋ฐ์ํด์ผํ๋ค!!!");
}
'Spring Boot' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์คํ๋ง with AWS] CRU ๊ธฐ๋ฅ - RestTemplate์ผ๋ก API ํ ์คํธ (0) | 2021.07.10 |
---|---|
[์คํ๋ง with AWS] MockMvc๋ฅผ ์ด์ฉํ API ํ ์คํธ ์ฝ๋ (0) | 2021.07.10 |
[02] ์ํ ๋๋ฉ์ธ ๊ฐ๋ฐ (0) | 2021.07.08 |
[02] Entity/table ์ค๊ณ & ํ์ ๋๋ฉ์ธ ๊ฐ๋ฐ (0) | 2021.07.08 |
[02] Jpashop ์ค์ตํ๊ธฐ ์ , remind (0) | 2021.07.08 |