개발자 Dongbaek

Spring boot 도메인 분석 설계

개발자Dongbaek — Fri, 18 Nov 2022 14:11:18 +0900

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8-JPA-%ED%99%9C%EC%9A%A9-1/dashboard

실전! 스프링 부트와 JPA 활용1 - 웹 애플리케이션 개발 - 인프런 | 강의

실무에 가까운 예제로, 스프링 부트와 JPA를 활용해서 웹 애플리케이션을 설계하고 개발합니다. 이 과정을 통해 스프링 부트와 JPA를 실무에서 어떻게 활용해야 하는지 이해할 수 있습니다., - 강

www.inflearn.com

소프트웨어 개발 단계

1. 요구사항 분석 // 이번 포스팅에서 다룰 주제

문제 분석 단계
개발할 소프트웨어의 기능과 제약조건, 목표등을 소프트웨어 사용자와 함께 명확히 정의
요구명세서 작성

2. 시스템 명세

시스템이 무엇을 수행해야하는 가를 정의
시스템 기능 명세서 작성

3. 설계

시스템 명세 단계에서 정의한 기능을 실제로 수행하기 위한 방법을 논리적을 결정하는 단계
- 시스템 구조 설계 - 시스템을 구성하는 내부 프로그램이나 모듈간의 관계와 구조 설계
- 프로그램 설계 - 프로그램 내의 각 모듈에서의 처리 절차나 알고리즘을 설계
- 사용자 인터페이스 설계 - 사용자가 시스템을 사용하기 위해 보여지는 화면 설계

4. 프로그래밍

설계 단계에서 논리적을 결정한 알고리즘을 프로그래밍 언어를 사용하여서 실제 프로그램을 작성하는 단계

5. 테스트

1. 단위 테스트
- 단위 테스트는 응용 프로그램에서 테스트 가능한 가장 작은 소프트웨어를 실행하여 예상대로 동작하는지 확인하는 테스트이다.
2. 통합 테스트
- 통합 테스트는 단위 테스트보다 더 큰 동작을 달성하기 위해 여러 모듈들을 모아 이들이 의도대로 협력하는지 확인하는 테스트이다.
3. 인수 테스트
- 인수 테스트는 사용자 스토리(시나리오)에 맞춰 수행하는 테스트이다.

6. 유지보수

도메인 분석 설계

1. 요구사항 분석

요구사항 명세서가 공통적으로 가지고 있는 특징들

ID : 내부 규칙에 따라 식별자를 부여한다. 하나의 요구사항에 하나의 식별자이다.
화면명 : 어느 화면에서 구현할 기능인지 기재한다. 화면에 속하지 않는 요구사항도 있을 수 있다.
요구사항명 : 요구사항의 설명을 요약하여 기재한다.
내용 : 요구사항의 설명을 요약하여 기재한다.
중요도 : 상중하, 1~5 등 내부 규칙에 따라 부여한다.
부서 / 작성자 : 요구사항을 기재한 담당자를 기재한다. 부서가 없는 경우 생략해도 무방하다.
날짜 : 요구사항을 기재한 날짜를 명시한다.
진행사항 (구현 여부) : 검토 예정, 진행 확정, 진행 불가, 추후 진행등 내부에서 결정된 사항을 기재한다.
버젼명 : 요구사항이 변경될 수 있으므로 버전으로 표기한다.
그 외 : 유형, 출처등

위의 양식을 따라 해당 강의 프로젝트의 요구사항 명세서를 작성해보면 다음과 같다.

ID	화면명	중요도	요구사항 내용	날짜	작성자	진행사항	버젼명
0001	회원	5	회원가입을 할 수있다.	11/16	동백	반영	0.1.0
0002	회원	3	찾고자 회원을 조회하여 찾을 수 있다.	11/16	동백	반영	0.1.5
0003	상품	4	상품을 등록한다.	11/24	고길동	미반영	0.2.0
0004	상품	3	등록된 상품들을 볼 수 있다.	12/1	둘리	미반영	0.2.5
0005	주문	4	상품을 주문한다.	12/1	송풍	미반영	0.2.5
0006	주문	4	주문했던 상품들의 내역을 볼 수 있다.	12/4	풍풍	반영	0.3.0
0007	상품	3	상품은 재고 관리가 필요하다.	12/10	동백	미반영	0.3.0
0008	상품	4	상품의 종류는 카테고리로 분류할 수 있다.	12/10	동백	미반영	0.3.0
0009	주문	5	상품 주문시 배송 정보를 입력할 수 있다.	12/10	동백	미반영	0.3.0

2. 도메인 모델과 테이블 설계

데이터 모델링 단계

1. 업무 파악 : 요구사항 명세서등을 작성하면서, 만들고자 하는 도메인에 대해서 파악해야한다.

위의 요구사항 명세서 참고

2. 개념적 데이터 모델링 : 개념적 데이터 모델링은 내가 하고자하는 일의 데이터 간의 관계를 구상하는 단계이다.

핵심 엔터티와 그들간의 관계를 발견하고, 그것을 표현하기 위해서 엔터티-관계 다이어그램(ER 다이어그램)을 생성하는 것이다.

도메인 모델과 테이블 설계

3. 논리적 데이터 모델링 : 구체화된 업무중심의 데이터 모델을 만들어 내는데 이것을 논리적인 데이터 모델링이라 한다.

이 단계에서 업무에 대한 Key, 속성, 관계등을 표시하며, 정규화 활동을 수행한다.

회원 엔티티 분석

회원(Member): 이름과 임베디드 타입인 주소( Address ), 그리고 주문( orders ) 리스트를 가진다.

주문(Order): 한 번 주문시 여러 상품을 주문할 수 있으므로 주문과 주문상품( OrderItem )은 일대다 관계
다. 주문은 상품을 주문한 회원과 배송 정보, 주문 날짜, 주문 상태( status )를 가지고 있다. 주문 상태는 열
거형을 사용했는데 주문( ORDER ), 취소( CANCEL )을 표현할 수 있다.

주문상품(OrderItem): 주문한 상품 정보와 주문 금액( orderPrice ), 주문 수량( count ) 정보를 가지고
있다. (보통 OrderLine , LineItem 으로 많이 표현한다.)

상품(Item): 이름, 가격, 재고수량( stockQuantity )을 가지고 있다. 상품을 주문하면 재고수량이 줄어든
다. 상품의 종류로는 도서, 음반, 영화가 있는데 각각은 사용하는 속성이 조금씩 다르다.

배송(Delivery): 주문시 하나의 배송 정보를 생성한다. 주문과 배송은 일대일 관계다.

카테고리(Category): 상품과 다대다 관계를 맺는다. parent , child 로 부모, 자식 카테고리를 연결한
다.

주소(Address): 값 타입(임베디드 타입)이다. 회원과 배송(Delivery)에서 사용한다.

강사님의 한마디

JPA 운영 단계에서는 다대다 관계를 쓰면 안된다! -> 일대다, 다대일로 풀어내야한다.

이는 아래 사진을 통해 설명하겠다.

양방향 관계가 아닌 일방향 관계를 사용해라

-> 예를 들어 위 ERD에서 멤버 < - > 주문의 경우 양방향으로 관계가 맺어져있는데(외래키) 시스템은 서로를 아예 동등하게 봄으로 주문이 멤버를 필요로 한다고 보는게 맞다.

회원 테이블 분석

ITEM: 앨범, 도서, 영화 타입을 통합해서 하나의 테이블로 만들었다. DTYPE 컬럼으로 타입을 구분한다.
- 싱글 테이블 전략

JPA 운영 단계에서는 다대다 관계를 쓰면 안된다! -> 일대다, 다대일로 풀어내야한다.

객체지향에서는 카테고리와 아이템 테이블을 서로 참조하는 것이 가능하다. 그러나 관계 데이터베이스는 그게 힘들다.
그렇기에 중간 카테고리_아이템 테이블을 만들어서 카테고리(1) <-> 카테고리_아이템(N), 카테고리_아이템(N) <-> 아이템(1)을 만들었다.

회원과 주문: 일대다 , 다대일의 양방향 관계다. 따라서 연관관계의 주인을 정해야 하는데, 외래 키가 있는 주
문을 연관관계의 주인으로 정하는 것이 좋다. 그러므로 Order.member 를 ORDERS.MEMBER_ID 외래 키와
매핑한다.

주문상품과 주문: 다대일 양방향 관계다. 외래 키가 주문상품에 있으므로 주문상품이 연관관계의 주인이다.
그러므로 OrderItem.order 를 ORDER_ITEM.ORDER_ID 외래 키와 매핑한다.

주문상품과 상품: 다대일 단방향 관계다. OrderItem.item 을 ORDER_ITEM.ITEM_ID 외래 키와 매핑한
다.

주문과 배송: 일대일 양방향 관계다. Order.delivery 를 ORDERS.DELIVERY_ID 외래 키와 매핑한다.
카테고리와 상품: @ManyToMany 를 사용해서 매핑한다.(실무에서 @ManyToMany는 사용하지 말자. 여기
서는 다대다 관계를 예제로 보여주기 위해 추가했을 뿐이다

강사님의 한마디

외래 키가 있는 곳(N측)을 연관관계의 주인으로 정해라.
> 연관관계의 주인은 단순히 외래 키를 누가 관리하냐의 문제이지 비즈니스상 우위에 있다고 주인으로 정하면
안된다.. 예를 들어서 자동차와 바퀴가 있으면, 사람들은 당연히 자동차가 중요하다고 생각을 하는데 이는 DB 설계에서는 잘못된 것이다. 일대다 관계에서 항상 다쪽에 외래 키가 있으므로 외래 키가 있는 바퀴를 연관관계의 주인으로 정하면 된다. 물론 자동차를 연관관계의 주인으로 정하는 것이 불가능 한
것은 아니지만, 자동차를 연관관계의 주인으로 정하면 자동차가 관리하지 않는 바퀴 테이블의 외래 키 값이
업데이트 되므로 관리와 유지보수가 어렵고, 추가적으로 별도의 업데이트 쿼리가 발생하는 성능 문제도 있
다

4. 물리적 데이터 모델링 : 최종적을 데이터를 관리할 데이터베이스를 선택하고, 선택한 데이터베이스에 실제 테이블을 만드는 작업을 말한다.

엔티티 클래스 개발

실무에서는 가급적 Getter는 열어두고, Setter는 꼭 필요한 경우에만 사용하는 것을 추천
- 이론적으로 Getter, Setter 모두 제공하지 않고, 꼭 필요한 별도의 메서드를 제공하는게 가장 이상적
  이다. 하지만 실무에서 엔티티의 데이터는 조회할 일이 너무 많으므로, Getter의 경우 모두 열어두는 것이
  편리하다. Getter는 아무리 호출해도 호출 하는 것 만으로 어떤 일이 발생하지는 않는다. 하지만 Setter는
  문제가 다르다. Setter를 호출하면 데이터가 변한다. Setter를 막 열어두면 가까운 미래에 엔티티에가 도대
  체 왜 변경되는지 추적하기 점점 힘들어진다. 그래서 엔티티를 변경할 때는 Setter 대신에 변경 지점이 명확
- 즉 엔티티에는 가급적 Setter를 사용하지 말자

DDL로 생성 후 반드시 그대로 사용하는 것이 아닌 만들어진 테이블과 필드들을 검토하기

회원 엔티티

package com.jpabook.jpashop.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Getter @Setter // Lombok을 사용하기에 게터 세터 어노테이션 가능
public class Member {

    @Id @GeneratedValue
    // 엔티티는 타입(ex:Meber)가 있으므로, id 필드만으로 구별이 쉽지만, DB의 경우 타입이 없기에 id라고 이름을 지으면 구별하기 어렵다.
    @Column(name = "member_id") // 보통 '테이블명+id'를 많이 사용한다. member_id라는 컬럼에 매핑한다.
    private Long id;

    private String username;

    @Embedded // 내장 타입을 포함했다는 의미
    private Address address;

    // 양방향 연관관계에서 주인이 아닌 쪽(1)은 MappedBy 속성을 넣어주고, 값은 연관 관계 주인인 Order.member
    // mappedBy를 지정해주면, 읽기 전용 필드가 되고, 값을 생성, 변경할 수 없다.
    // Order 테이블에 있는 member 필드에 의해서 나는 매핑된거야!
    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();
}

주문 엔티티

package com.jpabook.jpashop.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "orders") // 테이블 이름을 지정하지않으면 자동으로 Order
@Getter @Setter
public class Order {

    @Id @GeneratedValue
    @Column(name = "order_id") // DB 컬럼 명을 DB이름_필드이름
    private Long id;

    // 회원(1) : 주문(N)이기에, 주문(N)Many에 to 회원 외래키(FK)One를 둔다.
    @ManyToOne(fetch = FetchType.LAZY) // FetchType.Lazy는 JPA의 프록시와 지연로딩의 기초적인 내용을 공부해야한다.
    @JoinColumn(name = "member_id") // FK이름 지정
    private Member member; // Order.member

    // 양방향 연관관계 -> 양쪽에 모두 서로의 외래키가 존재하는 경우
    // Db는 외래키 하나만 바꾸면 되지만, 객체 지향은 둘 다 바꿔줘야 한다. 이 간극을 해결하기 위해서 객체 지향에서 둘 중 하나를 주인으로 정한다.
    // 이 경우는 연관관계 주인을 정해주어야 한다. 그 이유는 Order.member를 통해 값을 바꿀 수도있고, Member.orders를 통해 값을 바꿀 수 있기에
    // 예를 들어 Order.member는 값을 변경했는데, 연관된 Member.orders는 값이 변경되지 않은 경우 둘 중 뭘 믿어야할지 JPA는 어려워함
    // 그래서 둘 중 N측(Order)을 주인으로 설정한다.
    // 그렇게하면 Order.member를 변경했을 경우, JPA는 Order.member를 변경했다는 것을 인지하고, 그 것을 중점으로 DB 업데이트를 한다.


    // 양방향 연관관계에서 주인이 아닌 쪽(1)은 MappedBy 속성을 넣어주고, 값은 연관 관계 주인인 OrderItem.order
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL) // 부모 엔티티가 영속화될 때 자식 엔티티도 같이 영속화되고, 부모 엔티티가 삭제될 때 자식 엔티티도 삭제되는 등 특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 전이되는 것을 의미합니다.
    // cascade = CascadeType.ALL를 통해서 orderItems에 데이터를 넣어두고,
    private List<OrderItem> orderItems = new ArrayList<>();

    /* 기존 방식 = 1. Order 엔티티 저장하고 2. 그다음 Order.OrderItem들을 엔티티당 각각 persist를 호출해야 했음.\
        3. 그다음 마지막으로 다시 Order를 Persist 해줘야함.
     persist(orderItemA)
     persist(orderItemB)
     persist(orderItemC)
     persist(order)
     */

    /* 현재 방식 = Casacade.All은 persist를 전파시켜주어서(영속성 전이), Order를 persist하면 Order.orderItems를 같이 persist해준다.
        삭제 또한 마찬가지로 같이 진행해준다.
    persist(order)
     */

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    // Order.delivery또한 Order가 persist될 때 같이 persist된다.
    @JoinColumn(name = "delivery_id")
    private Delivery delivery; // 배송 정보

    private LocalDateTime orderDate; // 주문 시간
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status; // 주문상태 [ORDER. CANCEL]

    //==연관 관계 메소드==//
    /*
    양방향 관계의
    Order랑 Member가 있을 때, Member가 주문하면 Member.orders에도 넣어주어야한다.
    그리고 Order.member에도 저장을 해야한다.

     */

    public void setMember(Member member){ // 주문한 멤버를 세팅할 때,
        this.member = member; // Order.member에 멤버를 넣어준다.
        member.getOrders().add(this); // Order.member.orders에도 해당 주문을 넣어준다. 즉 this는 Order 객체를 가리킨다.
    }

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

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

주소 엔티티

package com.jpabook.jpashop.domain;

import lombok.Getter;

import javax.persistence.Embeddable;

@Embeddable // JPA Entity안의 Column을 하나의 객체로써 사용을 하고 싶을 때 사용, 어딘가에 내장될 수 있음을 알림
@Getter // 값 타입은 반드시 Getter만 사용하자. 그 이유는 생성될 때의 값이 변경되면 안되기 때문이다.
public class Address {

    // 다른 엔티티에서 Address안의 엔티티를 Address라는 하나의 객체로 사용할 수 있다.
    private String city;
    private String streets;
    private String zipcode;

    // public, protected중 protected로 설정하는 것을 추천
    protected Address() { // JPA가 생성할 때 @Embeddable가 있는 클래스는 리프랙션, 프록시등의 기술을 사용하기 위해서,기본 생성자를 요구한다.

    }

    // > 참고: 값 타입은 변경 불가능하게 설계해야 한다.
    //> @Setter 를 제거하고, 생성자에서 값을 모두 초기화해서 변경 불가능한 클래스를 만들자. JPA 스펙상 엔티
    // 티나 임베디드 타입( @Embeddable )은 자바 기본 생성자(default constructor)를 public 또는
    // protected 로 설정해야 한다. public 으로 두는 것 보다는 protected 로 설정하는 것이 그나마 더 안전
    // 하다.
    //> JPA가 이런 제약을 두는 이유는 JPA 구현 라이브러리가 객체를 생성할 때 리플랙션 같은 기술을 사용할 수있도록 지원해야 하기 때문이다
    public Address(String city, String streets, String zipcode) {
        this.city = city;
        this.streets = streets;
        this.zipcode = zipcode;
    }

}

주문 엔티티

package com.jpabook.jpashop.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "orders") // 테이블 이름을 지정하지않으면 자동으로 Order
@Getter @Setter
public class Order {

    @Id @GeneratedValue
    @Column(name = "order_id") // DB 컬럼 명을 DB이름_필드이름
    private Long id;

    // 회원(1) : 주문(N)이기에, 주문(N)Many에 to 회원 외래키(FK)One를 둔다.
    @ManyToOne(fetch = FetchType.LAZY) // FetchType.Lazy는 JPA의 프록시와 지연로딩의 기초적인 내용을 공부해야한다.
    @JoinColumn(name = "member_id") // FK이름 지정
    private Member member; // Order.member

    // 양방향 연관관계 -> 양쪽에 모두 서로의 외래키가 존재하는 경우
    // Db는 외래키 하나만 바꾸면 되지만, 객체 지향은 둘 다 바꿔줘야 한다. 이 간극을 해결하기 위해서 객체 지향에서 둘 중 하나를 주인으로 정한다.
    // 이 경우는 연관관계 주인을 정해주어야 한다. 그 이유는 Order.member를 통해 값을 바꿀 수도있고, Member.orders를 통해 값을 바꿀 수 있기에
    // 예를 들어 Order.member는 값을 변경했는데, 연관된 Member.orders는 값이 변경되지 않은 경우 둘 중 뭘 믿어야할지 JPA는 어려워함
    // 그래서 둘 중 N측(Order)을 주인으로 설정한다.
    // 그렇게하면 Order.member를 변경했을 경우, JPA는 Order.member를 변경했다는 것을 인지하고, 그 것을 중점으로 DB 업데이트를 한다.


    // 양방향 연관관계에서 주인이 아닌 쪽(1)은 MappedBy 속성을 넣어주고, 값은 연관 관계 주인인 OrderItem.order
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL) // 부모 엔티티가 영속화될 때 자식 엔티티도 같이 영속화되고, 부모 엔티티가 삭제될 때 자식 엔티티도 삭제되는 등 특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 전이되는 것을 의미합니다.
    // cascade = CascadeType.ALL를 통해서 orderItems에 데이터를 넣어두고,
    private List<OrderItem> orderItems = new ArrayList<>();

    /* 기존 방식 = 1. Order 엔티티 저장하고 2. 그다음 Order.OrderItem들을 엔티티당 각각 persist를 호출해야 했음.\
        3. 그다음 마지막으로 다시 Order를 Persist 해줘야함.
     persist(orderItemA)
     persist(orderItemB)
     persist(orderItemC)
     persist(order)
     */

    /* 현재 방식 = Casacade.All은 persist를 전파시켜주어서(영속성 전이), Order를 persist하면 Order.orderItems를 같이 persist해준다.
        삭제 또한 마찬가지로 같이 진행해준다.
    persist(order)
     */

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    // Order.delivery또한 Order가 persist될 때 같이 persist된다.
    @JoinColumn(name = "delivery_id")
    private Delivery delivery; // 배송 정보

    private LocalDateTime orderDate; // 주문 시간
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status; // 주문상태 [ORDER. CANCEL]

    //==연관 관계 메소드==//
    /*
    양방향 관계의
    Order랑 Member가 있을 때, Member가 주문하면 Member.orders에도 넣어주어야한다.
    그리고 Order.member에도 저장을 해야한다.

     */

    public void setMember(Member member){ // 주문한 멤버를 세팅할 때,
        this.member = member; // Order.member에 멤버를 넣어준다.
        member.getOrders().add(this); // Order.member.orders에도 해당 주문을 넣어준다. 즉 this는 Order 객체를 가리킨다.
    }

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

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

주문아이템 엔티티

package com.jpabook.jpashop.domain;

import com.jpabook.jpashop.domain.Item.Item;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;

@Entity
@Table(name="order_item")
@Getter @Setter
public class OrderItem { // 주문(1) - 주문&아이템(N) - 아이템(1)

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

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "item_id")
    private Item item; // 주문 상품

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order; // 주문

    private int orderPrice; // 주문 당시의 가격
    private int count; // 주문 당시의 수량

}

아이템 엔티티

package com.jpabook.jpashop.domain.Item;

import com.jpabook.jpashop.domain.Category;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE) // 상속관계 전략을 부모 엔티티(클래스)에 해주어야한다.
// 싱글 테이블 전략시 부모 엔티티를 기준으로 자식 엔티티들이 모두 한 테이블에 생성된다.
@DiscriminatorColumn(name = "dtype") // type별로 구분하는 것
@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> cagegories = new ArrayList<Category>();
}

앨범 엔티티

package com.jpabook.jpashop.domain.Item;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue("M")
@Getter @Setter
public class Movie extends Item {

    private String director;
    private String actor;
}

책 엔티티

package com.jpabook.jpashop.domain.Item;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue("B") // 싱글 테이블이기에, DB에서는 자식 테이블들을 분리할 기준이 필요하다.
@Getter @Setter
public class Book extends Item {

    private String author;
    private String isbn;
}

영화 엔티티

package com.jpabook.jpashop.domain.Item;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;

@Entity
@DiscriminatorValue("M")
@Getter @Setter
public class Movie extends Item {

    private String director;
    private String actor;
}

카테고리 엔티티

package com.jpabook.jpashop.domain;

import com.jpabook.jpashop.domain.Item.Item;
import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;
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는 최대한 피하는게 좋고, 중간 테이블을 만들어주는 게 맞다.
    // ex) 카테고리 - 카테고리&아이템 - 아이템
    // 다대다관계는 @JoinTable을 통해서 중간 테이블을 만들어주어야한다.
    // @JoinTable은 각 테이블들의 PK값들을 인자로 받아서, 중계 테이블을 만들어준다.
    // 실전에서 사용하지않는 이유는 중간 테이블에 각 테이블 PK 말고는 값을 추가할 수 없기 때문이다.
    @ManyToMany
    @JoinTable(name = "category_item",
            joinColumns = @JoinColumn(name = "category_id"), // joinColumns는 중간 테이블에 있는 category_id
            inverseJoinColumns = @JoinColumn(name = "item_id")) // inverseJoinColumns는 중간 테이블에 있는 item_id
    private List<Item> items = new ArrayList<>();

    // Category 구조는 같은 엔티티 내의 계층구조이다. 카테고리(부모) 1 : N 카테고리(자식)
    // 부모는 하나이니까 ManyToOne
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "parent_id")
    private Category parent;

    // 자식은 여러개니까 OneToMany
    @OneToMany(mappedBy = "parent") //
    private List<Category> child = new ArrayList<>();

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

배송 엔티티

package com.jpabook.jpashop.domain;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.*;

@Entity
@Getter @Setter
public class Delivery {

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

    // OneToOne 또한 반드시 연관관계의 주인을 정해주어야한다.
    // 이 때 주인은 어느쪽에서 더 많이 참조하는지를 보면서 정하면 된다. 예를 들어서
    // 유저가 주문.배송을 찾는 것과 배송.주문을 찾는 것중 주문.배송을 더 많이 찾기에 주문에 FK를 넣는다.
    @OneToOne(mappedBy = "delivery", fetch = FetchType.LAZY)
    private Order order;

    @Embedded
    private Address address;

    // Enum Type은 무조건 STRING으로 하자. ORDINAL로 할 경우 도중 데이터 변경시 장애가 생긴다.
    @Enumerated(EnumType.STRING)
    private DeliveryStatus status; // ENUM [READY(준비), COMP(배송)]

}

Enum 클래스들

package com.jpabook.jpashop.domain;

public enum DeliveryStatus {
    READY, COMP
}

package com.jpabook.jpashop.domain;

public enum OrderStatus {
    ORDER, CANCEL
}

https://galid1.tistory.com/592

JPA - Entity의 가독성을 높이자(@Embedded, @Embeddable, @AttributeOverride 사용법)

@Embedded, @AttributeOverride JPA에서는 Entity안의 값을 조금 더 의미있는 값으로 표현하기 위해 응집된 하나의 객체로 데이터를 표현합니다. 이번 포스팅에서는 이 처럼 JPA의 Entity를 조금 더 확실한 의

galid1.tistory.com

엔티티 설계시 주의점

Setter가 모두 열려있다. 변경 포인트가 너무 많아서, 유지보수가 어렵다. 나중에 리펙토링으로 Setter 제거
- 세터 없이 개발하는 방법은 추후 설명을 해주신다고 하셨음.

모든 연관관계는 지연로딩으로 설정!
- 즉시로딩은 예를 들어서 멤버를 조회할 때 연관된 주문도 한번에 조회하는 것이다.
- 즉시로딩( EAGER )은 예측이 어렵고, 어떤 SQL이 실행될지 추적하기 어렵다. 특히 JPQL을 실행할 때 N+1
  문제가 자주 발생한다.
  - N+1을 쉽게 설명하면 멤버를 조회할 때 연관된 모든 테이블들을 조회하는 것이다.
  - N+1의 뜻은 날린 쿼리는 1개인데, 그에 따른 결과 쿼리는 N개임을 의미한다.
- 실무에서 모든 연관관계는 지연로딩( LAZY )으로 설정해야 한다.
  연관된 엔티티를 함께 DB에서 조회하고자 하면, fetch join 또는 엔티티 그래프 기능을 사용한다.
- @XToOne(OneToOne, ManyToOne) 관계는 기본이 즉시로딩이므로 직접 지연로딩으로 설정해야 한
  다.

Fetch join과 엔티티 그래프는 뭘까???

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

JPA에서 컬렉션은 언제 사용될까???

하이버네이트 기존 구현: 엔티티의 필드명을 그대로 테이블의 컬럼명으로 사용
하이버네이트 신규 구현: 엔티티의 필드명을 테이블의 컬럼명 스타일에 맞게 아래와 같이 바꿔준다.
- 스프링 부트 신규 설정 (엔티티(필드) → 테이블(컬럼))
- 카멜 케이스 → 언더스코어(memberPoint member_point)
- .(점) → _(언더스코어)
- . 대문자 → 소문자

Spring 실전편

개발자Dongbaek — Tue, 15 Nov 2022 03:23:13 +0900

https://spring.io/guides

Spring | Guides

spring.io

공식 문서는 사랑이다

순서

1. 프로젝트 환경설정

2. 요구사항 분석

3. 도메인과 엔티티, 테이블 설계

4. 아키텍쳐 구성(Controller, Service, Repository)

5. 핵심 비즈니스 로직 개발(회원, 상품, 주문)

회원, 상품, 주문 도메인 개발
핵심 비즈니스 로직 개발
테스트 케이스 검증
도메인 주도 설계 이해

6. 테스트

7. 웹 계층 개발

학습 방법

처음부터 끝까지 직접 코딩하면서 공부하기

강의 목표

기술(Spring, JPA)들을 이미 알고있는 사람들이, 최대한 기술을 잘 사용할 수 있게 만들어주는 것

프로젝트 환경설정

1. 프로젝트 생성

1-1. https://start.spring.io/ 에서 기본 설정들을 저장하고, 프로젝트 생성(generate)

1-2. 파일 압축 풀고, 저장후 IntelliJ에서 import나 Open을 통해서 폴더를 열어준다.

1-3. build gradle을 확인해주고, main 디렉토리의 Application, Test 실행해보고, 정상적으로 실행되는지 확인

// 혹시나 invalid source release 에러가 생겼다면

https://sohee-dev.tistory.com/134

[Mac/ Spring Boot] IntelliJ - invalid source release 해결 방법

에러 내용 Execution failed for task ':compileJava'. > invalid source release: 11 JDK 버전과 project language level이 달라서 생기는 에러입니다. 해결 방법 File -> Project Structure 저는 Project language level 이 11로 설

sohee-dev.tistory.com

1-4. http://127.0.0.1:8080로 접속해보기

1.5 lombok 설치가 잘되었는지 확인하기

windows 기준 : File - settings - 검색창에 plugins 서치

lombok이 잘 설치되어있다면 File - settings - 검색창에 Annotation processor 서치후 Enable 체크

그 후 아무 클래스나 만들고 @Getter @Setter등의 어노테이션을 적어보기

라이브러리에 대해서

Gradle은 의존관계가 있는 라이브러리를 함께 다운로드한다.

Spring boot 핵심 라이브러리

spring-boot-starter-tomcat: 톰캣 (웹서버)
spring-webmvc: 스프링 웹 MVC
spring-boot-starter-thymeleaf: 타임리프 템플릿 엔진(View)
JPA, Hibernate, Spring data JPA // Spring data JPA는 스프링과 JPA를 먼저 이해하고 사용해야 하는 응용 기술이다.
spring-boot-starter(공통): 스프링 부트 + 스프링 코어 + 로깅
- spring-boot
  - spring-core
- spring-boot-starter-logging
  - logback, slf4j

테스트 라이브러리

spring-boot-starter-test
- junit: 테스트 프레임워크
- mockito: 목 라이브러리
- assertj: 테스트 코드를 좀 더 편하게 작성하게 도와주는 라이브러리
- spring-test: 스프링 통합 테스트 지원

2. View 환경 설정

1단계에서 Thymeleaf를 설치했어야한다.

Thymeleaf의 장점은 HTML의 마크업을 최대한 깨지 않는다는 점이고,

단점은 반드시 태그를 닫아주어야 한다는 점이다. <br>또한 닫아주어야 한다.</br>

spring-boot-devtools라는 라이브러리를 추가해주고, build - recompile을 하면 개발 도중 html을 변경해도 서버를 재시작 하지않아도 된다.

View : 화면을 그리는데 집중

위치 : resources/templates/hello.html

<html>
<head xmlns:th="https://www.thymeleaf.org"> <!- thymeleaf 문법을 사용하겠다.-->
<body>
Hello
<p th:text="'안녕하세요. ' + ${data}">안녕하세요. 손님</p> <!- thymeleaf 문법을 사용하고, Controller(=Views.py)에서 보낸 인자 출력  -->
</body>
</head>
</html>

Controller : 비즈니스 로직을 처리하는데 집중

위치 : hello.hellospring/controller

@Controller // controller는 반드시 Annotation을 해주어야 함
public class HelloController {

    @GetMapping("hello") // HTTP의 Get을 의미
    // /hello url로 들어오면 해당 함수가 매핑이 된다.
    public String hello(Model model) {
        model.addAttribute("data", "hello!"); // data라는 key 값에 hello!라는 value 전송
        return "hello"; // resources:templates 폴더 밑에 있는 "hello" 이름을 가진 템플릿을 Render
    }
  }

Controller에서 리턴 값으로 문자를 반환하면 뷰 리졸버(viewResolver)가 화면을 찾아서 처리 함
- Spring boot 템플릿엔진 기본 viewName 매핑
- resource:templates/ {viewName} + .html
  1. 컨트롤러에서 "hello" 반환
  2. 뷰 리졸버에서 resource/templates 디렉토리 아래의 hello.html을 찾아 매핑 시켜줌.

3. H2 DB 설치 및 JPA와 DB 설정, 동작 확인

H2는 개발이나 테스트 용도로 가볍고 편리한 DB, 웹 화면 제공
https://www.h2database.com

윈도우 설치 버전: https://h2database.com/h2-setup-2019-10-14.exe
윈도우, 맥, 리눅스 실행 버전: https://h2database.com/h2-2019-10-14.zip
https://www.h2database.com

H2 설치후 H2 콘솔 실행하기
데이터베이스 파일 생성 방법
- jdbc:h2:~/jpashop(프로젝트명으로) (최소 한번)
- ~/jpashop.mv.db 파일 생성 확인
- 이후 부터는 jdbc:h2:tcp://localhost/~/jpashop 이렇게 접속

JPA와 DB 설정

1. 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 # 하이버네이트가 생성한 모든 sql과 로그를 남길 수 있다.
    # org.hibernate.type: trace

2. 실제로 동작하는지 확인을 위해 엔티티를 만든다.

package com.jpabook.jpashop;

import lombok.Getter;
import lombok.Setter;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
@Getter @Setter // Lombok을 사용하기에 게터 세터 어노테이션 가능
public class Member {

    @Id @GeneratedValue
    private Long id;

    private String username;
}

3. 레포지토리도 만든다.

package com.jpabook.jpashop;

import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Repository
public class MemberRepo {

    @PersistenceContext
    private EntityManager em; // @PersistenceContext를 등록해놓으면 스프링이 알아서 엔티티매니저를 생성해준다.

    public Long save(Member member) {
        em.persist(member); // 멤버 엔티티 영속 컨텍스트에 저장 -> DB로 전달
        return member.getId();
    }

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

4. Shift + Ctrl + T로 테스트 클래스 생성하기

package com.jpabook.jpashop;

import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.junit.runner.RunWith;
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.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringRunner.class) // JUnit에게 Spring에 관련된 것을 테스팅한다 말해줘야함.
@SpringBootTest
public class MemberRepoTest {
    @Autowired
    MemberRepo memberRepo; // 의존성 주입

    @Test
    @Transactional // DB에 접근할 때는 반드시 트랜잭션 안에서 실행되어야한다.
    @Rollback(false)
    public void testMember() {
        //given
        Member member = new Member();
        member.setUsername("memberA");

        //when
        Long savedId = memberRepo.save(member);
        Member findMember = memberRepo.find(savedId);

        //then
        // 실제 잘 저장되었는지 확인
        Assertions.assertThat(findMember.getId()).isEqualTo(member.getId());
        Assertions.assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
        Assertions.assertThat(findMember).isEqualTo(member); // true가 반환된다. 그 이유는 같은 트랜잭션 내에서 조회하면 같은 영속성 컨텍스트 안에 있기에, ID가 같다면 같은 엔티티로 인식함.
    }
}

위 테스트 메소드를 실행하면 위 SQL이 실행된다.

Spring에서는 테스트의 경우 테스트가 끝나면 실행했던 SQL문을 다시 롤백한다.
- Rollback(false)일시 롤백을 하지 않는다.

5. 실제 DB에 가서, 잘 저장되었는지 확인한다.

오류 해결하기

https://www.inflearn.com/questions/15495

테스트 도중 에러 발생 - 인프런 | 질문 & 답변

FAILURE: Build failed with an exception. * What went wrong: Execution failed for task ':test'. > No tests found for given includes: [jpabook.jpashop....

www.inflearn.com

쿼리 파라미터 로그 남기기

쿼리 파라미터 로그를 남기는 것이 중요하다.

?, ?에 무엇이 들어갔는지(= 값이 잘 전달되었는지)

방법 1 : 로그에 다음을 추가하기 org.hibernate.type : SQL 실행 파라미터를 로그로 남긴다.

logging:
  level:
    org.hibernate.type: trace # 파라미터의 인자 타입과 값을 보여준다.

인자 - 값

방법 2 : ?, ?를 직접적으로 보기 위해서 외부 라이브러리를 사용하면 된다.

https://github.com/gavlyukovskiy/spring-boot-data-source-decorator

GitHub - gavlyukovskiy/spring-boot-data-source-decorator: Spring Boot integration with p6spy, datasource-proxy, flexy-pool and s

Spring Boot integration with p6spy, datasource-proxy, flexy-pool and spring-cloud-sleuth - GitHub - gavlyukovskiy/spring-boot-data-source-decorator: Spring Boot integration with p6spy, datasource-p...

github.com

Spring 기초 정리본

개발자Dongbaek — Sun, 6 Nov 2022 00:08:06 +0900

Spring 기술 그 자체에 매몰되지말자!
어떻게 기술을 사용해야 하는지 초점을 두자!

프로젝트 환경설정

먼저 스프링 부트 스타터 사이트로 이동해서 스프링 프로젝트 생성을 한다.

https://start.spring.io

Gradle Project : Life Cycle을 도와주는 Tool
Group : 기업 도메인 명
Artifact : 빌드된 결과물
Dependencies : 어떤 라이브러리를 사용할 것인지
- Spring Web
- Thymeleaf : 템플릿 엔진

Spring Boot 버전은 SNAPSHOT, M1 같은 미정식 버전을 제외하고 최신 버전을 사용하시면 됩니다

Gradle 전체 설정

plugins {
	id 'org.springframework.boot' version '2.7.4'
	id 'io.spring.dependency-management' version '1.0.14.RELEASE'
	id 'java'
}

group = 'hello'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11' // 자바 11버젼

repositories {
	mavenCentral() // 라이브러리들을 다운받을 특정 사이트
}

dependencies { // Spring은 의존 관계의 라이브러리들을 모두 땡겨온다. Gradle에서 확인 가능
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf' // spring io에서 선택했던 라이브러리들
	implementation 'org.springframework.boot:spring-boot-starter-web' // spring io에서 선택했던 라이브러리들
	runtimeOnly 'com.h2database:h2'
	testImplementation 'org.springframework.boot:spring-boot-starter-test' // 기본적으로 포함되는 라이브러리
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa' // jdbc 또한 포함
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

tasks.named('test') {
	useJUnitPlatform()
}

동작 확인
- src : 자바 파일은 src에 있다고 생각하기
- 기본 메인 클래스 실행 : src/main/java/hello.hellospring/HelloSpringApplication
- 스프링 부트 메인 실행 후 에러 페이지로 간단하게 동작 확인 (http://localhost:8080)

IntelliJ Gradle 대신에 자바 직접 실행

최근 IntelliJ 버전은 Gradle을 통해서 실행 하는 것이 기본 설정이다. 그러나 이렇게 하면 실행 속도가 느리기에 IntelliJ로 실행시키는 것이 실행 속도가 더 빠르다.

File - Setting

라이브러리 확인하기

Gradle은 의존관계가 있는 라이브러리를 함께 다운로드한다.

Spring boot 라이브러리

spring-boot-starter-tomcat: 톰캣 (웹서버)
spring-webmvc: 스프링 웹 MVC
spring-boot-starter-thymeleaf: 타임리프 템플릿 엔진(View)
spring-boot-starter(공통): 스프링 부트 + 스프링 코어 + 로깅
- spring-boot
  - spring-core
- spring-boot-starter-logging
  - logback, slf4j

테스트 라이브러리

spring-boot-starter-test
- junit: 테스트 프레임워크
- mockito: 목 라이브러리
- assertj: 테스트 코드를 좀 더 편하게 작성하게 도와주는 라이브러리
- spring-test: 스프링 통합 테스트 지원

Spring은 너무 거대하기에, 필요한 것을 찾는 능력이 매우 중요하다!

스프링 웹 개발 기초

웹 페이지를 개발하는 3가지 방법

정적 컨텐츠
MVC와 템플릿 엔진
API

정적 컨텐츠

html, css를 통해 정적으로 개발하는 방법 → html 파일 이름 그 자체로 서버로 올라간다.

MVC와 템플릿 엔진

View : 화면을 그리는데 집중

위치 : resources/templates/hello.html

<html>
<head xmlns:th="https://www.thymeleaf.org"> <!- thymeleaf 문법을 사용하겠다.-->
<body>
Hello
<p th:text="'안녕하세요. ' + ${data}">안녕하세요. 손님</p> <!- thymeleaf 문법을 사용하고, Controller(=Views.py)에서 보낸 인자 출력  -->
</body>
</head>
</html>

Controller : 비즈니스 로직을 처리하는데 집중

위치 : hello.hellospring/controller

@Controller // controller는 반드시 Annotation을 해주어야 함
public class HelloController {

    @GetMapping("hello") // HTTP의 Get을 의미
    // /hello url로 들어오면 해당 함수가 매핑이 된다.
    public String hello(Model model) {
        model.addAttribute("data", "hello!"); // data라는 key 값에 hello!라는 value 전송
        return "hello"; // resources:templates 폴더 밑에 있는 "hello" 이름을 가진 템플릿을 Render
    }
  }

Controller에서 리턴 값으로 문자를 반환하면 뷰 리졸버(viewResolver)가 화면을 찾아서 처리 함
- Spring boot 템플릿엔진 기본 viewName 매핑
- resource:templates/ {viewName} + .html
  1. 컨트롤러에서 "hello" 반환
  2. 뷰 리졸버에서 resource/templates 디렉토리 아래의 hello.html을 찾아 매핑 시켜줌.

빌드하고 실행하기

콘솔로 이동 → cmd로 이동하기
./gradlew → gradlew.bat를 실행한다.
cmd에서 gradlew.bat를 실행하려면 gladlew를 타이핑하고, 엔터를 친다.
gradlew build

  	@Controller // controller는 반드시 Annotation을 해주어야 함
	public class HelloController {
  	@GetMapping("hello-mvc")
        public String helloMvc(@RequestParam(value = "name", required = false) String name, Model model) { // 외부에서 파라미터, 인자를 받고자 할 때, @RequestParam 사용
            model.addAttribute("name", name);
            return "hello-templates";
        }
    }

RequestParam이란?
- https://heavenly-appear.tistory.com/302

[스프링] @RequestParam에 대한 이해 - parameter를 쉽게 컨트롤하기

스프링에서는 컨트롤러로 사용할 클래스 상단에 @Controller 지정하며 유용하게 사용할수 있는 기능들이 있다. 그중에 @RequestParam에 대해서 알아볼까합니다. 1. 단일 파라미터 변환 private ModelAndView r

heavenly-appear.tistory.com

인자로 데이터를 받는 MVC 패턴 프로세스

url에서 인자를 받음
해당 url에 매핑된 컨트롤러 실행
모델에 인자값 저장 후 템플릿 Render
View에서 모델값(=인자로 받은 값) 사용

API

API를 보내는 방법들

1. @ResponseBody 문자 반환

    @GetMapping("hello-string") // ResponseBody 문자 반환
    @ResponseBody
    public String helloString(@RequestParam("name") String name) {
        return "hello" + name;
    }

문자 반환은 자주 쓰이지 않음
@ResponseBody를 사용하면 뷰 리졸버를 사용하지 않음 → 즉 HTML을 렌더링하는게 아니라 API를 응답해줌
대신 HTTP의 Body에 문자 내용을 직접 반환해준다.

2. @ResponseBody 객체 반환

    @GetMapping("hello-api") // ResponseBody 객체 반환
    @ResponseBody
    public Hello helloApi(@RequestParam("name") String name) { // url 인자로 넘겨받은 값을 String 형의 name 변수에 저장
        Hello hello = new Hello(); // 객체 생성
        hello.setName(name); // 객체 메소드를 통해 변수 지정
        return hello; // 객체(=Json 반환)
    }
    
     static class Hello { // static class는 상위 클래스와 독립적으로 유지되게 도와줌
        private String name; // private이기에 getter와 setter를 통해 외부에서 접근 가능케 함. = Property 접근 방식

        public String getName(){ // getter와 setter 단축기 : ALT + ENTER
            return name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

대부분 이 방법을 사용한다.
@ResponseBody를 사용하고, 객체를 반환하면 객체가 JSON으로 변환된다.

@ResponseBody의 사용 원리

HTTP의 BODY에 문자 내용, 객체를 직접 반환
중요 !!! : viewResolver 대신에 HttpMessageConverter 가 동작
- 기본 문자처리 : StringHttpMessageConverter
- 기본 객체처리 : MappingJackson2HttpMessageConveter
- 커스터마이징 가능하지만 거의 그대로 사용한다
byte 처리 등등 기타 여러 HttpMessageConveter가 기본으로 등록 되어있음
클라이언트의 HTTP Accept 헤더와 서버의 컨트롤러 반환 타입 정보 둘을 조합해서 HTTPMessageConverter가 선택된다.

예제를 통해 알아보는 Spring boot 백엔드 개발

일반적인 개발 순서

비즈니스 요구사항 정리
회원 도메인과 리포지토리 만들기 → 저장소
회원 리포지토리 테스트 케이스 작성
회원 서비스 개발 → 실제 비지니스 로직
회원 서비스 테스트 → Junit

일반적인 Spring boot 개발 순서

Domain 생성
Repository 생성
Service 생성
Controller 생성

일반적인 웹 애플리케이션 계층 구조

컨트롤러 : 웹 MVC의 컨트롤러 역할
- Url과 매핑된 메소드에서 유저의 요청에 응답해 서비스에서 만든 로직을 이용해 객체, 데이터를 전달해주는 역할

package hello.hellospring.controller;

import hello.hellospring.domain.Member;
import hello.hellospring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
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
public class MemberController { // @Controller를 사용하면, Spring Container에서 스스로 MemberController 객체를 생성해서 Spring에서 저장하고,관리한다.
                                // 이를 Spring Container에서 bin이 관리된다고 표현한다.

    // private final MemberService memberService = new MemberService();
    // 이런식으로 new를 사용해 객체를 생성하면, 각 컨트롤러마다 각자 new 객체를 생성할 수 있기 때문에 
    // Spring Container로부터 등록한 후 받아서 사용할 수 있게 해야한다.

    private final MemberService memberService;

    // 의존성이 생성자를 통해서 들어오는 걸 생성자 주입이라고 한다.
    // 생성자 주입을 사용하는 것을 추천
    @Autowired // 생성자에 @Autowired가 있으면, Spring bin에 등록되어 있는 memberService 객체를 가져와 연결 시켜줌 -> Dependency Injection
    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }

    /*
     @AutoWired private final MemberService memberService; // 필드 주입 방법 -> 중간에 변경할 수 없기에 비추

    @Autowired // setter 주입 방법 -> 누군가가 호출했을 때 public으로 되어있어야 하기에, 보안 문제 생김
    public void setMemberService(MemberService memberService) {
        this.memberService = memberService;
     */

    @GetMapping("/members/new")
    public String createForm() {
        return "members/createMemberForm";
    }

    @PostMapping("/members/new")
    public String create(MemberForm form) { // MemberForm과 연결시켜줌
        Member member = new Member();
        member.setName(form.getName()); // form에서 입력받은 이름을 member domain에서 객체로 생성

        memberService.join(member); // 생성한 객체를 회원가입 로직에 넘김

        return "redirect:/"; // Django의 redirect와 같은데, 홈 화면으로 바로 보냄
    }

    @GetMapping("/members")
    public String List(Model model) {
        List<Member> members = memberService.findMembers(); // 모든 멤버 객체들을 다 가져온다.
        model.addAttribute("members", members); // members라는 key 값에 members라는 value 전송
        return "members/memberList";
    }
}

서비스 : 핵심 비즈니스 로직 구현
- 리포지토리의 데이터를 이용해 비즈니스 로직들을 구현한다.
- Service에서는 기획자도 알 수 있도록 비즈니스에 가까운 네이밍을 지어야한다!

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

// Testing을 쉽게 하는 방법
// 1. Ctrl + Shift + T -> Create New Test -> Junit으로 선택하고, 테스팅할 메소드 선택

//@Service  @Service는 MemberService를 Spring에 등록시켜주는 역할을 한다. -> Django에서 view, model 상속받는 것과 같다 생각하기
public class MemberService {

    // Repository 객체 생성
    // MemberService가 메모리 회원 리포지토리를 직접 생성하게 했습니다.
    // 인터페이스 사용법 : 인터페이스로 구현 객체를 사용하려면 다음과 같이 인터페이스 변수를 선언하고 구현 객체를 대입해야 합니다. 인터페이스 변수는 참조 타입이기 때문에 구현 객체가 대입될 경우 구현 객체의 번지를 저장합니다.
    // 인터페이스 변수 = new 구현객체;
    private final MemberRepository memberRepository; // 객체 변수에 final로 선언하면 그 변수에 다른 참조 값을 지정할 수 없습니다. 원시 타입과 동일하게 한번 쓰여진 변수는 재변경 불가합니다. 단, 객체 자체가 immutable하다는 의미는 아닙니다. 객체의 속성은 변경 가능합니다

    //@Autowired // 생성자에 @Autowired가 있으면, Spring bin에 등록되어 있는 MemberRepository 객체를 가져와 연결 시켜줌 -> Dependency Injection
    // MemberService - 연결 -> MemberRepository
    public MemberService(MemberRepository memberRepository) { // MemberService 입장에서 외부에서 객체를 넘겨주는 것을 Dependency Injection이라고 한다.
        // 3. 2단계에서 넘겨줬던 인자를 받아서 memberRepository로 저장
        // 4. 이렇게 하면 테스팅 Repository와 Service Repository가 같아진다.
        this.memberRepository = memberRepository;
    }

    // 회원가입 기능
    public long join(Member member) {
        validateDuplicateMember(member);// 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }
    
    // 중복 회원 검증 기능
    private void validateDuplicateMember(Member member) { // ctrl + t -> Refactory와 관련된 단축기
        memberRepository.findByName(member.getName())
                .ifPresent(m -> { // member.getName()이 Null이 아니면, 즉 만약 값이 있으면 예외처리를 해라
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
                });
    }
    
    // 전체 회원 조회
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    // 1명의 유저 반환
    public Optional<Member> findOne(long memberId){
        return memberRepository.findById(memberId);
    }
}

리포지토리 : 데이터베이스에 접근하여서, 도메인 객체를 DB에 저장하고 관리
- 리포지토리는 인터페이스와 인터페이스 구현체로 만들어진다.
- 아래 코드는 JPA 방식 리포지토리 구현체

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import java.util.List;
import java.util.Optional;

@Transactional // JPA를 사용할 때는 항상 @Transactional을 어노테이션 해야한다.
public class JPAMemberRepo implements MemberRepository{

    private final EntityManager em; // JPA는 EntityManager를 통해서 모든 동작을 한다.
    // JPA는 내부적으로 Datasource를 다 탑재하고있다.

    public JPAMemberRepo(EntityManager em) {
        this.em = em;
    }

    @Override
    public Member save(Member member) {
        em.persist(member); // .persist()는 이 메서드가 호출되면 article은 managed(영속)상태로 진입하게 됩니다.
        /*
        persist 는 새로운 entity 를 영속성 컨텍스트내에서 관리하고 싶을 때 사용합니다.
        entityManager.persist(xxx) 를 호출하면 바로 insert 쿼리가 동작합니다.
         */
        return member;

    }

    @Override
    // pk 같은 경우 .find로 매핑한다.
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id); // 첫 인자로는 조회할 타입, 두번째 인자로는 식별자를 넣어주면 된다.
        // .find는 실제로 DB에서 값을 찾아온다. 추가로 Optional로 한번 감싸서 값을 가져오는데, 얘는 해당 ID의 객체가 없다면 Null을 반환한다.
        return Optional.ofNullable(member);
    }

    @Override
    // pk가 아닌 경우, jpql이라는 객체 지향 쿼리를 사용한다.
    public Optional<Member> findByName(String name) {
        List<Member> result = em.createQuery("select m from Member m where m.name= :name", Member.class)
                .setParameter("name", name) // 외부(인자로 받아온 값)에서 파라미터를 설정할 수 있습니다.
                .getResultList(); // 결과를 컬렉션으로 반환한다. 결과가 없으면 빈 컬렉션이 반환된다. 1건이면 1건만 들어간 컬렉션이 반환된다

        return result.stream().findAny();
    }

    @Override
    // pk가 아닌 경우, jpql이라는 객체 지향 쿼리를 사용한다.
    public List<Member> findAll() {  // ctrl + alt + N = Inline(하나의 문장으로 합치기)
        return em.createQuery("select m from Member m", Member.class) // Member(=m) Enitity 자체를 Select 해, 두번째 인자는 타입을 적어준다.
                // jpql은 객체를 대상으로 쿼리를 보내고, 객체를 .
                .getResultList();
    }
}

도메인 : 비즈니스 도메인 객체 ex) 회원, 주문, 쿠폰 등등 주로 데이터베이스에 저장하고 관리됨
- 아래 Member Class를 하나의 DB Table이라 생각하면 편하다.

package hello.hellospring.domain;

import javax.persistence.*;

// JPA는 자바의 표준 ORM 인터페이스고 여러 구현체들이 있다.
@Entity // 이렇게 @Entity 어노테이션을 하면, JPA가 관리하는 엔티티가 되는거다.
public class Member {

    @Id // pk값으로 매핑시켜준다.
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB가 알아서 value를 생성해주는 걸 IDENTITY라고 한다.
    private Long id; // 데이터를 구분하기 위해서 시스템에서 저장한 아이디

    @Column(name = "username") // DB에 있는 username과 아래 name 변수를 매핑시켜준다.
    private String name; // 닉네임

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

클래스들간의 의존관계

Repository 테스트 케이스 작성 방법

위치 : src/test/java 하위 폴더에 생성한다.
이러한 Test를 먼저 만들고, 리포지토리를 만드는 것을 TDD라고 한다.

package hello.hellospring.repositiory;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemoryMemberRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.assertj.core.api.Assertions.*;

class MemoryMemberRepositoryTest {

    MemoryMemberRepository repository = new MemoryMemberRepository(); // 테스트할 Repository의 객체를 생성한다.

    @AfterEach // 매우 중요!!! @AfterEach는 메소드가 끝날때마다 실행되는 콜백 함수
    // 즉 save()가 실행되고, 호출 또 findByName()가 호출되고 실행
    public void afterEach() {
        repository.clearStore(); 
    }

    @Test // @Test 어노테이션을 사용하면, 해당 메소드를 바로 테스팅 실행할 수 있다.
    public void save() {
        // 테스트할 기능에 넣어줄 값들을 입력한다.
        Member member = new Member();
        member.setName("Spring");

        // repository 객체의 save 메소드에 값을 넘겨서 저장시킨다. = DB 역할
        repository.save(member);

        // save시 ID를 부여하였으므로, 잘 부여되었는지 확인한다.
        Member result = repository.findById(member.getId()).get(); // Optional에서는 get()으로 값을 꺼낼 수 있다.
        // 위 프로세스
        // 1. domain에 있는 프로퍼티(id, name)를 Member 객체를 통해 지정
        // 2. Repository의 객체를 통해서 save() 메소드 호출 -> DB에 저장
        // 3. Member 새로운 객체에 2단계의 객체를 이용해 findById() 메소드로 멤버 객체의 Id값을 가진 객체를 저장합니다.

        assertThat(result).isEqualTo(member); // 1~2단계에서 멤버 객체에 저장했던 것과, DB에 있는 것이 같은지 검증
        // assertThat은 첫 인자가 isEqualTo 인자와 같은지를 반환해줌
        // 실무에서는 해당 테스트를 통과 못하면 다음 단계로 아예 못넘어가게 막아버림
    }

    @Test
    public void findByName() {
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member1.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();

        assertThat(result).isEqualTo(member1); // findByName으로 인자로 넘겼던 Name의 멤버 객체를 잘 불러왔는지 검사
    }

    @Test
    public void findAll() {
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member1.setName("spring2");
        repository.save(member2);

        List<Member> result = repository.findAll(); // 여러 Member 객체들을 findAll()로 모두 불러와서 Member 객체 자료형 리스트에 저장함
        // List<자료형> 리스트 명 = new ArrayList(or LinkedList)<자료형(생략가능)>();

        assertThat(result.size()).isEqualTo(2);
    }

}

한번에 여러 테스트를 실행하면, DB에 직전 테스트의 결과가 남을 수 있다. 위의 @AfterEach는 이러한 문제를 해결해주기 위해 존재하는데, @AfterEach는 각 테스트가 종료될때 마다 이 기능을 실행한다.
테스트는 각각 독립적으로 실행되어야 하며, 테스트 순서에 의존관계가 있는 것은 좋은 테스트가 아니다!!
@BeforeEach는 각 테스트 실행전에 호출되며, 테스트가 서로 영향이 없도록 항상 새로운 객체를 생성하고, 의존 관계도 새로 맺어준다.
@SpringBootTest : 스프링 컨테이너와 테스트를 함께 실행하도록 하는 어노테이션 = 통합 테스트
@Transactional : 테스트 케이스에 이 어노테이션이 있으면, 테스트 시작 전에 트랜잭션을 시작하고, 테스트 완료 후에 항상 롤백한다. 이렇게 하면 DB에 데이터가 남지 않으므로 다음 테스트에 영향을 주지 않는다.

스프링 빈과 의존관계

스프링(Spring) 컨테이너가 관리하는 자바 객체를 빈(Bean)이라 한다.

제어의 역전이란, 간단히 말해서 객체의 생성 및 제어권을 사용자가 아닌 스프링에게 맡기는 것이다. 지금까지는 사용자가 new연산을 통해 객체를 생성하고 메소드를 호출했다. IoC가 적용된 경우에는 이러한 객체의 생성과 사용자의 제어권을 스프링에게 넘긴다. 사용자는 직접 new를 이용해 생성한 객체를 사용하지 않고, 스프링에 의하여 관리당하는 자바 객체를 사용한다. 이 객체를 '빈(bean)'이라 한다.

빈 등록하는 방법은 2가지가 있다.

컴포넌트 스캔과 자동 의존관계 설정
자바 코드로 직접 스프링 빈 등록하기

컴포넌트 스캔과 자동 의존관계 설정을 통한 빈 등록

@Component 어노테이션이 있으면 스프링 빈으로 자동 등록된다.
@Controller 컨트롤러가 스프링 빈으로 자동 등록된 이유는 컴포넌트 스캔 때문이다..
@Component 를 포함하는 다음 애노테이션도 스프링 빈으로 자동 등록된다.
- @Controller
- @Service
- @Repository

@Service  @Service는 MemberService를 Spring에 등록시켜주는 역할을 한다. -> Django에서 view, model 상속받는 것과 같다 생각하기
public class MemberService {

    // Repository 객체 생성
    // MemberService가 메모리 회원 리포지토리를 직접 생성하게 했습니다.
    // 인터페이스 사용법 : 인터페이스로 구현 객체를 사용하려면 다음과 같이 인터페이스 변수를 선언하고 구현 객체를 대입해야 합니다. 인터페이스 변수는 참조 타입이기 때문에 구현 객체가 대입될 경우 구현 객체의 번지를 저장합니다.
    // 인터페이스 변수 = new 구현객체;
    private final MemberRepository memberRepository; // 객체 변수에 final로 선언하면 그 변수에 다른 참조 값을 지정할 수 없습니다. 원시 타입과 동일하게 한번 쓰여진 변수는 재변경 불가합니다. 단, 객체 자체가 immutable하다는 의미는 아닙니다. 객체의 속성은 변경 가능합니다

    @Autowired // 생성자에 @Autowired가 있으면, Spring bin에 등록되어 있는 MemberRepository 객체를 가져와 연결 시켜줌 -> Dependency Injection
    // MemberService - 연결 -> MemberRepository
    public MemberService(MemberRepository memberRepository) { // MemberService 입장에서 외부에서 객체를 넘겨주는 것을 Dependency Injection이라고 한다.
        // 3. 2단계에서 넘겨줬던 인자를 받아서 memberRepository로 저장
        // 4. 이렇게 하면 테스팅 Repository와 Service Repository가 같아진다.
        this.memberRepository = memberRepository;
    }

생성자에 @Autowired를 사용하면 객체 생성 시점에 스프링 컨테이너에서 해당 스프링 빈을 찾아서 주입한다. 생성자가 1개만 있으면 @Autowired는 생략할 수 있다.
생성자에 @Autowired 가 있으면 스프링이 연관된 객체를 스프링 컨테이너에서 찾아서 넣어준다. 이렇게
객체 의존관계를 외부에서 넣어주는 것을 DI (Dependency Injection), 의존성 주입이라 한다.
- 객체를 스프링이 직접 생성해주니까 우리는 연관 관계를 스프링에게 반드시 알려주어야 한다!!

스프링 빈 등록 이미지

스프링 빈 등록은 컴포넌트 스캔 방법에서 @Controller, @Service, @Repository를 통해 등록하고
의존 관계는 아래와 같이 연결해준다.

컨트롤러 → 서비스 의존관계 연결

@Controller
public class MemberController { // @Controller를 사용하면, Spring Container에서 스스로 MemberController 객체를 생성해서 Spring에서 저장하고,관리한다.
                                // 이를 Spring Container에서 bin이 관리된다고 표현한다.

    // private final MemberService memberService = new MemberService();
    // 이런식으로 new를 사용해 객체를 생성하면, 각 컨트롤러마다 각자 new 객체를 생성할 수 있기 때문에 
    // Spring Container로부터 등록한 후 받아서 사용할 수 있게 해야한다.

    private final MemberService memberService;

    // 의존성이 생성자를 통해서 들어오는 걸 생성자 주입이라고 한다.
    // 생성자 주입을 사용하는 것을 추천
    @Autowired // 생성자에 @Autowired가 있으면, Spring bin에 등록되어 있는 memberService 객체를 가져와 연결 시켜줌 -> Dependency Injection
    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }
}

서비스 → 레포지토리 의존관계 연결

public class MemberService {

    // Repository 객체 생성
    // MemberService가 메모리 회원 리포지토리를 직접 생성하게 했습니다.
    // 인터페이스 사용법 : 인터페이스로 구현 객체를 사용하려면 다음과 같이 인터페이스 변수를 선언하고 구현 객체를 대입해야 합니다. 인터페이스 변수는 참조 타입이기 때문에 구현 객체가 대입될 경우 구현 객체의 번지를 저장합니다.
    // 인터페이스 변수 = new 구현객체;
    private final MemberRepository memberRepository; // 객체 변수에 final로 선언하면 그 변수에 다른 참조 값을 지정할 수 없습니다. 원시 타입과 동일하게 한번 쓰여진 변수는 재변경 불가합니다. 단, 객체 자체가 immutable하다는 의미는 아닙니다. 객체의 속성은 변경 가능합니다

    //@Autowired // 생성자에 @Autowired가 있으면, Spring bin에 등록되어 있는 MemberRepository 객체를 가져와 연결 시켜줌 -> Dependency Injection
    // MemberService - 연결 -> MemberRepository
    public MemberService(MemberRepository memberRepository) { // MemberService 입장에서 외부에서 객체를 넘겨주는 것을 Dependency Injection이라고 한다.
        // 3. 2단계에서 넘겨줬던 인자를 받아서 memberRepository로 저장
        // 4. 이렇게 하면 테스팅 Repository와 Service Repository가 같아진다.
        this.memberRepository = memberRepository;
    }
}

의존관계는 필드 주입, 세터 주입, 생성자 주입 3가지 방법이 있는데, 위와 같은 생성자 주입을 권장한다.

스프링 DB 접근 기술

Spring에서 DB 접근하기

스프링 설정 변경 : DI

package hello.hellospring.service;

import hello.hellospring.repository.JPAMemberRepo;
import hello.hellospring.repository.MemberRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// Java Code로 직접 Spring Bean을 등록시키는 방법
// Spring이 실행될 떄 먼저 @Configuration이 있는 클래스에 들려서 @Bean이 있는 메소드들을 등록시킨다.

@Configuration
public class SpringConfig {

    private DataSource dataSource;
    private SpringConfig(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    private EntityManager em;

    @Autowired
    public SpringConfig(EntityManager em){
        this.em = em;
    }

    private final MemberRepository memberRepository;

    @Autowired
    public SpringConfig(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }


    @Bean
    public MemberService memberService() { // 리턴을 memberRepository()을 함으로써, AutoWired를 사용한 것 같은 효과를 누린다.
        return new MemberService(memberRepository); //
        //  new는 클래스 타입의 인스턴스(객체)를 생성해주는 역할을 담당한다.
        // Ctrl + p를 누르면, 어떤 인자를 필요로 하는지 알 수 있다.
    }

    @Bean
    public MemberRepository memberRepository() {
//
//        //return new MemoryMemberRepository(); // 인터페이스는 new가 안되니 구현체를 리턴
//        //return new JDBCRepo(dataSource);
        return new JPAMemberRepo(em);
//    }

}

DataSource는 데이터베이스 커넥션을 획득할 때 사용하는 객체이다. 스프링 부투는 데이터베이스 커넥션 정보를 바탕으로 Datasource를 생성하고, 스프링 빈으로 만들어준다. 그래서 DI를 받을 수 있다.
1. application.properties에 datasource 관련 정보(=데이터베이스 정보)들을 입력해준다.
2. SpringConfig에서 datasource를 import하고 객체를 만들어줌으로서 데이터베이스 정보를 가져온다.

스프링의 DI

개방-폐쇄 원칙(OCP, Open-Closed Principle)
- 확장에는 열려있고, 수정, 변경에는 닫혀있다.
스프링의 DI(Dependency Injection)를 사용하면 기존 코드를 전혀 손대지 않고, 설정만으로 구현 클래스를 변경할 수 있다.

domain을 통해서 DB에 직접적으로 접근하는 것을 피할 수 있다!!

Domain이 따로 필요한 이유!!!

https://devlog-wjdrbs96.tistory.com/209

[Spring] 스프링 웹 계층이란?

이번 글에서는 스프링은 어떤 계층이 존재하는지와 계층의 역할을 무엇인지, 프로젝트시 패키지를 어떻게 나누는 것이 좋은지에 대해 정리해보려 한다. 스프링의 계층은 Presentation Layer, Business,

devlog-wjdrbs96.tistory.com

jdbcTemplate

jdbcTemplate는 쿼리를 통해서 DB에 접근한다고 생각하기

package hello.hellospring.repository;


import hello.hellospring.domain.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Optional;

public class JDBCRepo implements MemberRepository {

    private final JdbcTemplate jdbcTemplate;

    @Autowired // 생성자가 하나만 있으면 @Autowired 생략 가능
    public JDBCRepo(DataSource dataSource) { // DataSource는 DB와 관계된 커넥션 정보를 담고있으며 빈으로 등록하여 인자로 넘겨준다. → 이 과정을 통해 Spring은 DataSource로 DB와의 연결을 획득한다.
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Override
    public Member save(Member member) {
        return null;
    }

    @Override
    public Optional<Member> findById(Long id) {
        // ResultSet(java.sql.ResultSet)은 executeQuery(String sql)을 통해 쿼리 실행하면 ResultSet타입으로 반환을 해주어 결과값을 저장할 수 있다.
        List<Member> result = jdbcTemplate.query("select * from member where id = ?", memberRowMapper(), id); // "select * from member where id = ?" 구문으로 Member 객체 자체를 반환받기 위해 RowMapper 사용
        return result.stream().findAny(); // stream()은 컬렉션에 있는 엘리먼트들을 하나씩 순회하면서 처리할 수 있는 코드 패턴이다. -> 여러 멤버 객체들중
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> result = jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name); // "select * from member where id = ?" 구문으로 Member 객체 자체를 반환받기 위해 RowMapper 사용
        return result.stream().findAny(); // stream()은 컬렉션에 있는 엘리먼트들을 하나씩 순회하면서 처리할 수 있는 코드 패턴이다. -> 여러 멤버 객체들중
    }

    @Override
    public List<Member> findAll() {
        return null;
    }

    /*
    RowMapper를 사용하면, 원하는 형태의 결과값을 반환할 수 있다.
    SELECT로 나온 여러개의 값을 반환할 수 있을 뿐만 아니라,
    사용자가 원하는 형태로도 얼마든지 받을 수 있다.
     */
    private RowMapper<Member> memberRowMapper() {
        return (rs, rowNum) -> { // alt + enter로 lambda로 변환 가능

            Member member = new Member();
            member.setId(rs.getLong("id"));
            member.setName(rs.getString("name"));
            return member; // result에 저장된 id, name을 추출해서 Member 객체로 반환
        };
    }
}

JPA

JPA는 기본적인 SQL도 JPA가 직접 만들어서 실행해준다.
JPA를 사용하면 SQL과 데이터 중심의 설계에서 객체 중심의 설계로 패러다임을 전환할 수 있다.
JPA를 사용하면 개발 생산성을 크게 높일 수 있다.

1. 먼저 build.gradle에 JPA, 데이터베이스 관련 라이브러리 추가

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'org.springframework.boot:spring-boot-starter-web'
//implementation 'org.springframework.boot:spring-boot-starter-jdbc'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'
testImplementation('org.springframework.boot:spring-boot-starter-test') {
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
}

2. 스프링 부트에 JPA 설정 추가

위치 : resources/application.properties

spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

show-sql : JPA가 생성하는 SQL을 출력한다.
ddl-auto : JPA는 테이블을 자동으로 생성하는 기능을 제공하는데 none 를 사용하면 해당 기능을 끈다.

JPA 엔티티 매핑

package hello.hellospring.domain;

import javax.persistence.*;

// JPA는 자바의 표준 ORM 인터페이스고 여러 구현체들이 있다.
@Entity // 이렇게 @Entity 어노테이션을 하면, JPA가 관리하는 엔티티가 되는거다.
public class Member {

    @Id // pk값으로 매핑시켜준다.
    @GeneratedValue(strategy = GenerationType.IDENTITY) // DB가 알아서 value를 생성해주는 걸 IDENTITY라고 한다.
    private Long id; // 데이터를 구분하기 위해서 시스템에서 저장한 아이디

    @Column(name = "username") // DB에 있는 username과 아래 name 변수를 매핑시켜준다.
    private String name; // 닉네임

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

JPA 회원 레포지토리

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import java.util.List;
import java.util.Optional;

@Transactional // JPA를 사용할 때는 항상 @Transactional을 어노테이션 해야한다.
public class JPAMemberRepo implements MemberRepository{

    private final EntityManager em; // JPA는 EntityManager를 통해서 모든 동작을 한다.
    // JPA는 내부적으로 Datasource를 다 탑재하고있다.

    public JPAMemberRepo(EntityManager em) {
        this.em = em;
    }

    @Override
    public Member save(Member member) {
        em.persist(member); // .persist()는 이 메서드가 호출되면 article은 managed(영속)상태로 진입하게 됩니다.
        /*
        persist 는 새로운 entity 를 영속성 컨텍스트내에서 관리하고 싶을 때 사용합니다.
        entityManager.persist(xxx) 를 호출하면 바로 insert 쿼리가 동작합니다.
         */
        return member;

    }

    @Override
    // pk 같은 경우 .find로 매핑한다.
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id); // 첫 인자로는 조회할 타입, 두번째 인자로는 식별자를 넣어주면 된다.
        // .find는 실제로 DB에서 값을 찾아온다. 추가로 Optional로 한번 감싸서 값을 가져오는데, 얘는 해당 ID의 객체가 없다면 Null을 반환한다.
        return Optional.ofNullable(member);
    }

    @Override
    // pk가 아닌 경우, jpql이라는 객체 지향 쿼리를 사용한다.
    public Optional<Member> findByName(String name) {
        List<Member> result = em.createQuery("select m from Member m where m.name= :name", Member.class)
                .setParameter("name", name) // 외부(인자로 받아온 값)에서 파라미터를 설정할 수 있습니다.
                .getResultList(); // 결과를 컬렉션으로 반환한다. 결과가 없으면 빈 컬렉션이 반환된다. 1건이면 1건만 들어간 컬렉션이 반환된다

        return result.stream().findAny();
    }

    @Override
    // pk가 아닌 경우, jpql이라는 객체 지향 쿼리를 사용한다.
    public List<Member> findAll() {  // ctrl + alt + N = Inline(하나의 문장으로 합치기)
        return em.createQuery("select m from Member m", Member.class) // Member(=m) Enitity 자체를 Select 해, 두번째 인자는 타입을 적어준다.
                // jpql은 객체를 대상으로 쿼리를 보내고, 객체를 .
                .getResultList();
    }
}

서비스 계층에 트랜잭션 추가

import org.springframework.transaction.annotation.Transactional

@Transactional
public class MemberService {}

스프링은 해당 클래스의 메서드를 실행할 때 트랜잭션을 시작하고, 메서드가 정상 종료되면 트랜잭션을 커밋한다. 만약 런타임 예외가 발생하면 롤백한다.
JPA를 통한 모든 데이터 변경은 트랜잭션 안에서 실행해야 한다.

스프링 데이터 JPA

스프링 데이터 JPA를 사용한다면 레포지토리에 구현 클래스 없이 인터페이스 만으로 개발을 할 수 있고, 반복 개발한 기본 CRUD 기능 또한 스프링 데이터 JPA가 모두 제공한다.
스프링 데이터 JPA는 JPA를 편리하게 사용해주는 도구이기에, 스프링 데이터 JPA를 먼저 학습해야한다.

스프링 데이터 JPA 회원 레포지토리

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface SpringDataJpaMemberRepository extends JpaRepository<Member,
Long>, MemberRepository {
 Optional<Member> findByName(String name);
}

Spring JPA와 데이터 JPA

https://velog.io/@junho918/Spring-Data-Jpa-JPA..%EA%B7%B8%EB%9E%98-%EC%95%8C%EA%B2%A0%EC%96%B4..-%EA%B7%B8%EB%9E%98%EC%84%9C-%EC%8A%A4%ED%94%84%EB%A7%81-%EB%8D%B0%EC%9D%B4%ED%84%B0-JPA%EB%8A%94-%EC%96%B4%EB%96%BB%EA%B2%8C-%EC%93%B0%EB%8A%94%EB%8D%B0

[Spring Data Jpa] JPA..그래 알겠어.. 그래서 스프링 데이터 JPA는 어떻게 쓰는데..

김영한님의 실전 Spring Data Jpa를 수강하고 정리한 문서 입니다. 강추! 최고최고. 인프런 김영한님 실전 스프링 데이터 JPA 링크딴거는 다 모르겠고, 기록할 부분만 기록해야겠다.\-h2 데이터베이스

velog.io

자바야 어 반갑다 - 객체 지향 프로그래밍이란?

개발자Dongbaek — Tue, 1 Nov 2022 00:09:21 +0900

2년전 전공 수업때 만났던 자바를 Spring 프레임워크를 위해 다시 공부하기로 하였다.

사실 어느정도는 기억할 줄 알고 바로

스프링 공부를 시작했지만

개같이 털려버리고, 강의를 통해 다시 기억을 더듬고자 한다.

ㅠ

객체지향언어, 상속, 객체, 의존관계등등 어렵고도 거부감이 드는 단어들을 초심자의 마음을 가지고 다시 공부해보도록 하자

레츠기릿

강의 출처 : https://cloudstudying.kr/lectures/195

09 클래스와 객체 | CloudStudying

# 클래스와 객체 ## 들어가며.. --- 우리는 이전 파트에서 자바의 기본 문법에 대해 알아보았다. ![클라우드스터딩-자바-기본-문법-파트-요약](https://i.imgur.com/wU3oHxo.png) 이번 파트에서는 데이터와

cloudstudying.kr

먼저 첫번째 강의에서는 객체 지향 프로그래밍의 전반적인 정의와 여러 개념들에 대해서 공부하였다.

객체 지향 프로그래밍은 쉽게 말해 조립식 프로그래밍이라 할 수 있다. 객체를 조립하여 전체 프로그램을 만드는 것이다.

장점은 조립식으로 프로그램을 만들기에, 고장이 나도 해당 부분만 수리하면 되고, 또 기능을 추가할 때 만들어서 끼워 넣으면 된다는 것이다. 즉 관리, 재사용, 확장에 매우 유용하다.

객체는 클래스를 통해서 만들어지는 데 그러면 클래스와 객체의 차이는 무엇일까?

클래스와 객체의 차이는 클래스는 객체를 만들기 위한 설계도이고, 객체는 설계도를 통해 만들어지는 부품이라는 것이다.

객체는 인스턴스(instance)라고도 부른다.

프로그램을 만들려면 여러 객체가 필요하고, 여러 객체를 만들려면, 객체별 클래스가 필요하다. 결과적으로,프로그램을 만들기 위해서는 클래스를 잘 만들어야 한다.

클래스를 잘 만들기 위해서는 먼저 클래스 다이어그램을 잘 만들어야한다.

클래스의 구조에 대해서 알아보자

클래스는 상태를 정의하는 필드와 동작을 정의하는 메소드로 나뉘어진다.

class Cat {
  /* 필드(상태) 영역 */
  String name;   // 이름
  String breeds; // 품종
  double weight; // 무게
  
  /* 메소드(동작) 영역 */
  void claw() {
    System.out.println("할퀴기!!");
  }
  void meow() {
    System.out.println("야옹!!");
  }
}

문제

주어진 코드는 두 개의 클래스, Main과 Dog로 이루어져있다. 아래의 클래스 다이어그램을 참조하여 Dog 클래스를 완성하고, 출력 예와 같은 결과를 얻으시오. (Main 클래스의 코드 그대로 사용 할 것)

출력 예

이름: null
품종: null
나이: 0

/* Main 클래스 */
public class Main {
  public static void main(String[] args) {
    // Dog 객체 생성
    Dog d = new Dog();
    
    d.name = "핫도그";
    d.breeds = "요크셔테리어";
    d.age = 2;  
    
  
    // Dog 객체 필드 값 출력
    System.out.printf("이름: %s\n", d.name);
    System.out.printf("품종: %s\n", d.breeds);
    System.out.printf("나이: %s\n", d.age);
  }
}

/* Dog 클래스 */
class Dog {
  /* 1. 필드 영역을 작성하시오. */
  String name;
  String breeds;
  int age;
  
  /* 2. 메소드 영역을 추가하시오. */
  void wag() {
    system.out.println("wak!");
  }
  
  void bark() {
    system.out.println("bark;");
  }
  
}

객체 생성 과정

위 Dog 클래스의 객체(인스턴스)를 만드는 코드는 아래와 같습니다.

// Dog 객체를 생성
new Dog();

일반적으로는 만든 객체를 다시 사용키 위해, 다음과 같이 변수로 이름을 붙여줍니다.

이는 숫자 86을 재사용하기 위해서 변수에 할당한 것과 같다.

// 객체 생성 후, dog1 변수에 연결
Dog dog1 = new Dog();

// 비교: 일반 변수
int score = 86;

생성된 객체는 연결된 변수에 닷(.) 연산을 함으로써, 접근할 수 있습니다.

// dog1 변수에 연결된 객체에 접근, name 변경.
dog1.name = "멍무이";

// dog1 변수에 연결된 객체에 접근, weight 변경.
dog1.weight = 4.27;

객체 생성시의 정확한 프로세스

1. new 연산자가 d 객체에 저장될 메모리 공간 할당

2. 생성자가 d 객체를 초기화

3. new 연산자가 새로 생성된 객체의 주소(reference) d 변수에 저장

4. d를 통해 Dog에 접근 가능

출처: https://sime.tistory.com/41 [심이 블로그:티스토리]

하나의 잘 설계된 클래스로, 여러 개의 객체를 만들 수 있습니다. 이는 마치, 붕어빵틀로 여러개의 붕어빵을 만드는 것과 같습니다.

/* 메인 클래스 */
public class BicycleTest {
  public static void main(String[] args) {
    // 자전거 객체 생성
    Bicycle b1 = new Bicycle();

    // 객체 필드값 초기화
    b1.name = "로드형 자전거";
    b1.weight = 7.25;
    b1.price = 326000;

    // 객체 정보 출력
    System.out.printf("b1->{%s, %.2f, %d}\n", b1.name, b1.weight, b1.price);
    
    /* 1. 새 자전거 객체 b2를 생성하시오. */
    /* 2. b2 객체의 필드를 초기화하시오. */
    /* 3. b2 객체 정보를 출력하시오. */
  }
}

/* 자전거 클래스 */
class Bicycle {
  /* 필드 */
  String name;    // 이름
  double weight;  // 무게
  int price;      // 가격

  /* 메소드 */
  void move() {
    System.out.println("자전거를 타고 이동합니다.");
  }
  
  void horn() {
    System.out.println("따르르릉! 지나갈게요~");
  }

아래는 Bicycle 클래스를 통해 두 객체를 생성하는 예입니다.

// 자전거 객체를 만들고, b1 변수에 대입
Bicycle b1 = new Bicycle();

// 자전거 객체 b2 생성
Bicycle b2 = new Bicycle();

b1과 b2는 서로 다른 객체이다. 상호 관계 X

객체는 생성, 초기화, 출력의 단계를 거친다.

생성

// 자전거 객체를 만들고, b1 변수에 대입
Bicycle b1 = new Bicycle();

초기화

b1.name = "산악자전거";
b1.weight = 7.25;
b1.price = 132000;

클래스를 통해 생성된 객체. 이를 인스턴스(instance)라 합니다. 아래는 Cat 인스턴스의 메소드인 meow()를 수행시키는 코드 예입니다.

Cat cat1 = new Cat();
cat1.meow(); // "야옹~"

이렇게 객체에 특정 동작을 수행시키는 것. 이를 “인스턴스 메소드 호출”이라 합니다.

클래스에서 동작을 하는게 아닌, 객체에서 동작을 하는 것이다!!

클래스 스코프

이러한 변수의 활동영역을 스코프(scope)라 합니다. 따라서 필드의 활동영역은 “클래스 스코프”가 됩니다.

필드의 활동 영역은 클래스 전체입니다. 따라서, 메소드 호출 시 필드를 사용할 수 있습니다.

class Dog {
    String name;
    int age;

    void bark() {
    // 해당 클래스의 필드 name을 사용
    System.out.println(name + "의 멍멍!");
}
}

각 객체에 저장된 필드를 메소드로 출력하거나 이용할 수 있다.

메소드 스코프

파라미터와 지역변수는 메소드 스코프를 가집니다. 다시 말해, 이들의 활동영역은 자신이 속한 메소드 내부입니다.

지역변수

여기서 지역변수란, 메소드 내부에 선언된 변수입니다.

class DrinkMachine {
  String output; // 필드 output 선언
  void pushButton(int num) { // 파라미터 num 선언
    // 지역변수 drinks 선언
    String[] drinks = {"콜라", "사이다", "맥주"};
    output = drinks[num];
  }
  void printOutput() {
    System.out.println(output);
  }
}

스코프 정리

클래스 스코프: 필드
메소드 스코프: 파라미터, 지역변수

프로그래머스 - 완주 하지못한 선수

개발자Dongbaek — Mon, 31 Oct 2022 22:47:25 +0900

문제 설명

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

제한사항

마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
completion의 길이는 participant의 길이보다 1 작습니다.
참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
참가자 중에는 동명이인이 있을 수 있습니다.

입출력 예

participant / completion / return

["leo", "kiki", "eden"]	["eden", "kiki"]	"leo"
["marina", "josipa", "nikola", "vinko", "filipa"]	["josipa", "filipa", "marina", "nikola"]	"vinko"
["mislav", "stanko", "mislav", "ana"]	["stanko", "ana", "mislav"]	"mislav"

입출력 예 설명

예제 #1
"leo"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #2
"vinko"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #3
"mislav"는 참여자 명단에는 두 명이 있지만, 완주자 명단에는 한 명밖에 없기 때문에 한명은 완주하지 못했습니다.

def solution(participant, completion): # 해시 참고 -> https://ablue-1.tistory.com/68
    hashDict = {}
    sumHash = 0
    
    for part in participant:
        hashDict[part] = hash(part) # 딕셔너리의 key값으로는 참가자의 이름을, value 값으로는 이름의 해시값(랜덤한 숫자)을 저장한다.
        sumHash += hash(part) # 이름에 대한 해시값들을 저장한다.
    
    for comp in completion:
        sumHash -= hash(comp) # completion에 있는 참가자들의 해시값을 일일이 빼주면 결국 완주하지 못한 선수의 해시값만 남을 것이다
    
    
    for k, v in hashDict.items(): # 딕셔너리의 value가 위에서 구한 완주하지 못한 선수의 value와 같다면 해당 값을 리턴해줌.
        if v == sumHash:
            ans = k
            
    return ans

프로그래머스 - 전화번호 목록 #파이썬

개발자Dongbaek — Mon, 31 Oct 2022 22:46:18 +0900

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

구조대 : 119
박준영 : 97 674 223
지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

제한 사항

phone_book의 길이는 1 이상 1,000,000 이하입니다.
- 각 전화번호의 길이는 1 이상 20 이하입니다.
- 같은 전화번호가 중복해서 들어있지 않습니다.

입출력 예제

phone_book / return

["119", "97674223", "1195524421"]	false
["123","456","789"]	true
["12","123","1235","567","88"]	false

입출력 예 설명

입출력 예 #1
앞에서 설명한 예와 같습니다.

입출력 예 #2
한 번호가 다른 번호의 접두사인 경우가 없으므로, 답은 true입니다.

입출력 예 #3
첫 번째 전화번호, “12”가 두 번째 전화번호 “123”의 접두사입니다. 따라서 답은 false입니다.

def solution(phone_book):
    answer = True
    phone_book.sort()
    
    for i in range(len(phone_book)-1): # 0, 1
        if phone_book[i+1] is not None:
            if phone_book[i] == phone_book[i+1][:len(phone_book[i])]: # 접두어이기 때문에
                answer = False
                break
            
    return answer

프로그래머스 - 기능개발 #파이썬

개발자Dongbaek — Mon, 31 Oct 2022 22:44:38 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42586?language=python3

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 설명

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

제한 사항

작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
작업 진도는 100 미만의 자연수입니다.
작업 속도는 100 이하의 자연수입니다.
배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

입출력 예

progresses / speeds / return

[93, 30, 55]	[1, 30, 5]	[2, 1]
[95, 90, 99, 99, 80, 99]	[1, 1, 1, 1, 1, 1]	[1, 3, 2]

입출력 예 설명

입출력 예 #1
첫 번째 기능은 93% 완료되어 있고 하루에 1%씩 작업이 가능하므로 7일간 작업 후 배포가 가능합니다.
두 번째 기능은 30%가 완료되어 있고 하루에 30%씩 작업이 가능하므로 3일간 작업 후 배포가 가능합니다. 하지만 이전 첫 번째 기능이 아직 완성된 상태가 아니기 때문에 첫 번째 기능이 배포되는 7일째 배포됩니다.
세 번째 기능은 55%가 완료되어 있고 하루에 5%씩 작업이 가능하므로 9일간 작업 후 배포가 가능합니다.

따라서 7일째에 2개의 기능, 9일째에 1개의 기능이 배포됩니다.

입출력 예 #2
모든 기능이 하루에 1%씩 작업이 가능하므로, 작업이 끝나기까지 남은 일수는 각각 5일, 10일, 1일, 1일, 20일, 1일입니다. 어떤 기능이 먼저 완성되었더라도 앞에 있는 모든 기능이 완성되지 않으면 배포가 불가능합니다.

따라서 5일째에 1개의 기능, 10일째에 3개의 기능, 20일째에 2개의 기능이 배포됩니다.

def solution(progresses, speeds):

    
    answer = [] # 결과를 담을 리스트
    time = 0 # 작업까지 걸린 시간
    worked = 0 # 이전 완료된 작업

    
    while len(progresses) > 0: # 작업 리스트가 빌 때까지 반복
        if (progresses[0] + speeds[0] * time) >= 100: # 작업이 완료된 경우 작업 완료 횟수 1을 증가시킨다.
            progresses.pop(0) # FIFO
            speeds.pop(0)   
            worked += 1 
        
        else: # 작업이 완료 되지않은 경우 
            if worked > 0: # 만약 완료된 이전 작업이 있다면 정답 리스트에 추가
                answer.append(worked)    
                worked = 0
            
            time += 1 # 작업에 걸리는 시간을 계속 더해준다.
    
    answer.append(worked) # 마지막 작업은 else문을 안거치기에 answer에 직접 추가해줌
    return answer

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon V-Log

개발자Dongbaek — Mon, 31 Oct 2022 22:34:41 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 13 회고 Part 4~5

개발자Dongbaek — Sun, 31 Jul 2022 21:37:51 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 4주차 회고

부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습니다...! 최선을 다해 공부하고, 리뷰하겠습니다! 부족한 글 보러 와주셔서 감사드립니다!

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

반가워요

반갑다 여러분

오늘은 저번 강의에 만들었던

점프맵 게임에 포션 기능과 포탈 기능을 구현해보도록 하겠다!

점프맵에 대한 기본적인 플레이 영상은 아래와 같다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

먼저 포션 기능을 구현해보도록 하겠다.

먼저 메이플처럼 특정 키를 눌렀을 때 포션을 먹을수도 아니면 포션 엔티티에 닿으면 포션을 먹도록 설정할 수 있는데 우리 같은 경우는 후자를 구현하겠다.

포션을 통해서 hp를 회복하기 위해서는 장애물 구현과 비슷하게 플레이어가 TriggerEvent 발생시 먹은 포션은 사라지고, hp가 증가하게 만들면 된다.

먼저 TriggerComponent를 extend해서 PotionTriggerComponent를 추가해주고,

해당 컴포넌트에 TriggerEnterEvent를 추가해주어야 한다.

# 반드시 heal Property를 만들어주어야한다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

그 다음으로 구현할 기능은 포탈 기능이다.

포탈을 만드는 방법은 2가지 방법이 존재한다.

1. Model List에서 Portal을 선택해 Scene에 배치하는 방법이다.

이 경우 모델에 Portal Component가 이미 포함되어 있다.

2. 그 다음으로는 직접 포탈을 만드는 방법이다.

먼저 엔티티를 배치하고, 엔티티에 Add Component를 통해 PortalComponent를 직접 추가해주는 방법이다.

우리는 1번 방법을 통해 포탈을 구현할 것이다.

포탈은 2개 이상 만들어야 한다.

포탈 엔티티를 만든 후 PortalEntityRef 프로퍼티에 목적지 포탈을 적어주면 된다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 13 회고 Part 3

개발자Dongbaek — Wed, 27 Jul 2022 21:06:09 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 4주차 27일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

반가워용

오늘도 반갑다 여러분

원래 오늘 충돌 기능을 회고에 써야했었는데 멍청한 내가 또 실수를 저질러버려서 어제 미리 작성해버렸다.....

아이쿠..

그래서 오늘은 노가리 아니 내가

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon

을 신청하고, 합격하게 된 스토리를 적어볼까한다.

안궁금한 사람들도 일단 들어는 보자

MOD라는 것을 알게된 것은 그리 오래로 건너가지는 않는다.

때는 멋쟁이사자처럼 10기를 합격하고 전체 OT를 줌으로 할 때였다.

비록 영상으로 뵙지만 사랑합니다 대장님...ㅠ

당시 나는 멋쟁이사자처럼을 합격하고 난 뒤 멋사 뽕(?)에 취해있었다.

신기한 이름, 그리고 단체 해커톤 대회!!!, 또 여러 대학들을 만날 수 있고, 또 체계적인 커리큘럼 등등!!!

크으으..

그런 취해버린 나에게 더 멋사뽕을 투여할 이야기를 들어버렸다.

당시 캡쳐했던 사진

바로 MOD였다.

메이플 리소스를 제공하여, 나만의 컨텐츠를 제작할 수 있다는 말에 더 이상 설명을 듣지 않고

나의 TODO 리스트에 MOD.... 라고 바로 적었었다.

그렇게 MOD 신청날이 가까오고,

나는 밤을 새고 커피를 마셔가며 신청서를 작성했다.

나는 더 좋은 아이디어를 짜내기 위해서 나를 채찍질 하고, 또 채찍질했다.

사실 잠을 꼬박 꼬박 잘잤다.

커피도 나는 사실 잘 못마신다.

화자가 열심히 했다는 것만 알아두자

신청서에서는 내가 다뤄본 프로그래밍 언어 및 프레임워크를 물어보는 질문과 MOD를 통해서 어떤 컨텐츠를 제작하고 싶은지를 물어보는 문항이 있었다.

나는 파이썬, 자바, C언어를 대학에서 공부하면서 다뤄봤고, 장고와 안드로이드 스튜디오 프레임워크를 다뤄봤기에 해당 문항은 어렵지 않게 작성하고, 만들고 싶은 컨텐츠를 물어본 문항도 어렵지 않게 적어서 냈다.

내가 만들고 싶다 제출했던 콘텐츠는 아래와 같다.

두번째는 치유 상담 위주의 콘텐츠입니다. 넓은 맵을 구성하여, 유저들이 자유롭게 돌아다니며 이야기도 하고, 퀘스트 및 미니게임을 하는 등 기존의 메이플과 비슷하지만,
가능하다면 맵의 곳곳에 자연스럽게 전문 상담사를 배치하여(ex) 헤네시스, 커닝시티등 돌아다니거나 고정 자리에서) 여러 유저들과 상담사와의 자유로운 이야기 및 상담과 캠프 파이어 같은 분위기 연출을 통해 유저들 서로도 각자의 아픔을 서로 나누고, 쓰다듬어 줄 수 있는 매개체가 되었으면 좋겠습니다. 오프라인에도 충분히 많은 상담소와 좋은 상담사분들이 존재하지만 본인이 직접 가서 대면으로 자신의 신분을 드러내고 상처들을 꺼내기란 사실 어렵습니다. 이미 사람에게 상처를 받았던 사람들은 쉽게 사람들에게 마음을 열기란 어려운 문제입니다. 그러나 온라인의 힘은 본인이 누구인지, 어떻게 생겼고, 어디가 컴플렉스인지를 보이지 않고 유저분들이 그들의 상처를 보다 쉽게 이야기하며, 치유받을 수 있다는 점에 있다고 생각합니다. 이러한 온라인의 장점과 메이플의 장점을 빌려서 사람을 치유하는 콘텐츠를 기획했습니다.

그렇게 나는 합격자 발표날을 기다리고, 기다렸다..

결과는 모두 알고 있다 싶이....

글을 쓰다보니 내가 무엇을 이야기 하고 싶었는지 잘 기억이 나지않는다.

단지 기억나는 것은 한 문장 뿐이었다...

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 13 회고 Part 2

개발자Dongbaek — Tue, 26 Jul 2022 22:12:48 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 4주차 26일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

재밌더라구요 ㅋㅋㅋ

이번 글에서는 저번 글에서 올렸던 게임 플레이 영상의 코드와 프로세스에 대해서 이야기해보겠다.

저번 글 주소

https://devdongbaek.tistory.com/153

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 13 회고

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 4주차 26일 회고 부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습..

devdongbaek.tistory.com

먼저 게임은 몬스터를 피해서 도착지까지 가는 게임이다. 유저는 공중을 날아다닐 수 있으며, 몬스터와 닿게 되면 유저의 HP가 감소하며, HP가 0이되면 유저는 몇 초간 움직일 수 없는 사망 상태가 된다. 시간이 지나면 다시 움직이며 플레이할 수 있다.

모두!! 위의 게임 규칙들을 하나 하나 뜯어보며, 어떤 코드를 적용시켰는지 알아볼까요??

넵

1. 유저는 공중을 날아다닐 수 있다. 이를 구현해보자!

위는 구현하는데 필요한 코드이다.

대략적으로 코드가 어떻게 동작하는지 알아보자

1. HandleKeyDownEvent를 통해서 유저가 키를 입력했을 때, 즉 LeftAlt(점프)키를 눌렀을 때 이벤트가 발생하게했다.

2. 모드를 Property로 설정해주고, Mode가 "Avoid_Obstacle"일 때만 해당 이벤트가 동작하도록 했다.

3. 그리고 CameraComponent.Damping을 통해서 유저의 이동을 카메라가 빠르게 따라오게 하였다.

4. rigidbody:SetForce(vector2(x방향, y방향))을 통해서 중력을 조절하여서, 밑으로 떨어지지않고 공중에 떠있게 할 수 있다.

2. 몬스터와 닿게 되면 유저의 HP가 감소하며, HP가 0이되면 유저는 몇 초간 움직일 수 없는 사망 상태를 구현한 코드를 아래 사진으로 알아보자

1. Damage를 각 엔티티마다 다르게 적용할 수 있게끔 Propery로 설정했다.

2. PlayDead()와 PlayerAlive() 함수를 만들어주고, 각 상태에 맞는 코드들을 작성해주었다.

1. 만약 충돌이 감지된 엔티티의 Id가 플레이어의 Id와 같다면, 즉 유저가 몬스터와 부딪혔다면 동작한다.

2. 만약 Take_Damage_Period, 유저가 공격을 받을 수 있는 상태(기간)이고, 유저에 체력이 0보다 작으면 아래 문장들이 동작한다.

Take_Damage_Period를 거짓으로 두어서 더이상 공격을 받지 않게 한다.
유저의 상태를 "사망 상태"로 변경한다.
위에서 작성한 PlayDead()를 호출한다.
5초간 유저의 사망 상태를 지속시킨다.
4초가 지난후 유저의 상태를 변경해주고,
유저의 체력과 위치를 초기화 시켜주고, Take_Damage_Period를 참으로 줌으로써 다시 공격을 받을 수 있게 한다.

3. 만약 Take_Damage_Period, 유저가 공격을 받을 수 있는 상태(기간)이고, 유저에 체력이 0보다 많으면 아래 문장들이 동작한다.

Take_Damage_Period를 거짓으로 두어서 더이상 공격을 받지 않게 한다.
입은 데미지 만큼 체력에서 제한다.
유저를 뒤로 밀려나게 만든다.
0.75의 시간을 준 다음 다시 Take_Damage_Period를 참으로 줌으로써 다시 공격을 받을 수 있게 한다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여 to the 러 to the 분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 13 회고

개발자Dongbaek — Tue, 26 Jul 2022 02:26:06 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 4주차 26일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

우수에 차는 밤이네여

두 개의 해커톤 대회를 준비하다 보니 최근에는 시간이 너무 빨리 지나간다.

난 아직 감자일뿐인데..

부족하고, 멍청한 나이지만 둘 다 최고의 결과를 만들기 위해서 정말 최선을 다하고있다.

그러나 최근에는 너무 피곤하고 지쳐서 내 스스로 정신승리를 하려고만 자꾸 한다.

나는 두 해커톤을 동시에 준비했으니까...

해커톤말고도 할 게 너무 많았으니까...

포기하지마..!

그랬으니까... 이 정도면 잘한거야

포기하지마!!!

어이...!

내가 제일 싫어하는 것은 스스로 이정도면 잘했다고 만족하는 것이다.

대회들이 끝나고 침대에서 일주일을 보내더라도, 스스로 후회하지 않을정도로 노력하고, 노력해보겠다!

가보장

이번 Chapter 13에서는 실제로 MOD를 통해서 게임을 만드는 방법을 자세히 배워보는 시간이었다.

이번 게시글에서는 게임 플레이 영상과 만들고 느낀 점에 대해서 집중적으로 설명하고, 추후 코드들과 코드 프로세스에 대해서 이야기 해보겠다!

먼저 플레이 영상이다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

만들면서 느낀점

나는 진짜 감자 대가리인 것 같다.

포테이토

분명 코드를 다 맞게 작성했는데, Trigger Event가 제대로 실행되지 않았다.

봤던 코드를 보고, 또 보고 모니터를 때리기전에

발견했다.

여러분은 틀린 부분이 바로 보이는가??

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 저거 하나에 1시간을 태웠다!!!

정말 바보

그래도 게임을 만들어보니 이제 정말 MOD 개발을 시작한다는 느낌을 들었다.

앞으로도 바보더라도 함께 쭉 가보자!!!!

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 12 회고

개발자Dongbaek — Sun, 24 Jul 2022 20:40:43 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 3주차 24일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

공부란 뭘까

이번 Chapter 12에서는 MOD 개발을 하는데 있어서 알아두면 유용한 것들에 대하여 배운 Chapter였다.

최근 Chapter와 다르게 가볍게 들을 수 있는 내용들이니 모두 긴장풀고 들어보자!

편하 개...

알아두면 유용할 것들을 코드와 영상을 통해서 쉽게 알아보자!

잠깐!

알아보기전에 Model에 대해 다시 개념 정리를 하자면 아래와 같다.

모델 : 엔티티에 컴포넌트를 추가해 모델화 할 수 있다.
Original Model : 빈 엔터티에서 컴포넌트들을 추가해 새로운 무언가를 만든 것이다.
Child Model : 기존 엔터티에서 상세 컴포넌트만 바뀐 것으로, 기존 엔티티에서 파생된 모델이다.
- 부모 모델과 자식 모델의 관계자식 모델에서는 자신보다 상위 모델인 부모 모델에서 추가한 컴포넌트를 삭제할 수 없다. 반대로 부모 모델에 새로운 어떤 컴포넌트 추가시 자식 모델에도 추가된다.
- 자식 모델의 기존 엔터티를 부모 모델이라 생각하시면 된다. 부모 모델이 자식 모델의 상위 개념이다.

기본 개념에 대해 다시 복습을 해봤으니 이제 알아보자!

동적 Spawn을 통해 Model을 스폰 시키는 방법

동적 spawn 구현시 SpawnByModelId 함수를 사용한다.

SpawnByModelId 함수 더 알아보기_SpawnService:SpawnByModelId를 사용하기 위해서는 엔티티로 생성할 모델이 WorkSpace에 추가되어 있어야 하며, 추가된 Model ID를 파라미터로 넘겨주어야 한다.
spawn을 클라이언트에서 구현시 나에게만 보인다. 반대로 서버에서 구현하면 유저 모두에게 보인다.
SpawnByModelId는 _SpawnService가 제공하는 스폰 관련 함수 중 하나이다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

그 다음으로는 엔티티 동적 생성이다.

동적 생성이란?

개발자가 모든 설정을 수동으로 작업해 엔티티를 생성하는 것이 아니라, 알아서 엔티티가 자동으로 생성되도록 하는 것이다. 주로 같은 모델의 엔티티를 여러개 생성할 때 사용한다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

2초에 하나씩 몬스터를 스폰시키는 코드이다.

*CallBack == (SetTimer) : 주기적으로 실행하는 것으로 함수의 경우 self.으로 호출한다. (일반 함수는 self:로 호출)

일정 시간을 두고 조금 기다렸다가 실행하거나 db에 저장하는 경우 등에 사용한다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 11 회고

개발자Dongbaek — Thu, 21 Jul 2022 18:45:42 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 3주차 21일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

오늘도 와줘서 고마워요 ㅠ

이번 챕터 11에서는 MOD의 UI 에디터에 대해서 공부하였다.

MOD에서는 UI 에디터를 통해서 화면 상에 출력되는 UI를 조작한다.

MOD의 UI 에디터는 아래와 같은 구성들을 지니고 있다.

1. 모델리스트 : 메이커에서 제공하는 다양한 UI Preset 활용 가능

UI 엔티티를 생성하는 방법은 2가지 방법이 있다.

기본 UI 모델을 선택해 배치하는 방법
UI Preset을 활용하는 방법

모델리스트

2. UI 경로 정보 : 선택된 UI 엔티티의 경로 정보를 얻어오는 기능

3. 캔버스 : 선택된 UI 엔티티의 배치 및 편집을 작업하는 공간

게임 실행 시 캔버스에 배치했던 레이어대로 화면에 출력된다.

4. 기본 도구 : 이미지 & 버튼 등의 UI 엔티티 배치 가능

기본 UI 엔티티는 기본 도구를 통해 배치할 수 있고, 기본 도구에 추가되어있는 기본 UI 엔티티는 아래와 같다.

이미지
버튼
스크롤뷰
텍스트
입력텍스트

5. UI Group 편집창 : UI Group의 선택 / 추가 / 삭제 기능 제공

우리는 스크립트를 이용해 UI 엔티티를 제어할 수 있다.

우리가 UI 엔티티를 생성하였다면, UI 엔티티에 접근해 엔티티를 제어해야한다.

UI 엔티티는 월드에서의 엔티티로의 접근법과 동일하게 접근할 수 있다.

즉 스크립트에서 엔티티 객체를 불러올 수 있다는 것이다.

버튼 클릭 시 서버에서의 처리를 요청하는 예시 코드

Function:
    [server only]
    void OnbeginPlay()
    {
        local button = _EntityService:GetEntityByPath("ButtonEntityPath") 
        -- 가져 올 버튼 엔티티 경로를 "ButtonEntityPath"에 입력합니다.
        button:Connect("ButtonClickEvernt", self.OnButtonClickClient, self)
    }

    [client only] 
    Void OnButtonClickClient()
    {
        --processing in client..
        self:OnButtonClickServer()
    }

    [server] 
    void OnButtonClickServer()
    {
        log("Start processing on the server")
    }

서버에서 처리 결과를 UI로 출력할 때의 예시 코드

Property:
    [sync]
    number time=0

Function:
    [server only]
    void OnUpdate(number delta)
    {
        self.time = self.time + delta
        if self.time >= 3 then
            self.time = 0
            self:ShowToastMessage("Time Reset")
        end
    }[client]
    void ShowToastMessage (string text)
    {
        local toastUiEntity = _EntityService:GetEntityByPath("UIEntityPath")
        -- 가져 올 UI 엔티티 경로를 "UIEntityPath"에 입력합니다.

        local textComponent = toastUIEntity.TextComponent

        -- print toast message
        textComponent.Text = text
        toastUIEntity:SetEnable(true)

        --reservate hide toast message
        local callback = function()
                toastUIEntity:SetEnable(false)
            end
        _TimerService:SetTimerOnce(callback,3)
    }

또한 UI를 상황과 조건에 따라 노출 시킬 수 있다.

UI 엔티티는 화면의 입출력을 담당하는 엔티티이기에, 상황과 조건에 따라 UI를 띄우거나 숨길 수 있어야 한다.

만약 몬스터를 잡고있는데 채팅창이 계속 떠서 방해하거나, 보스전에서 내 HP바가 안보이면 큰 낭패이지 않은가... ㅠㅠ

ㅠ

Entity 함수인 setEnable 을 통해 알림 팝업 및 토스트 메시지를 띄우는 기능을 구현할 수 있다.

void ShowToastMessage ()
{
    local toastUIEntity = _EntityService:GetEntityByPath("/ui/.../EntityPath")
    toastUIEntity:SetEnable(true)
}
 
void HideToastMessage ()
{
    local toastUIEntity = _EntityService:GetEntityByPath("/ui/.../EntityPath")
    toastUIEntity:SetEnable(false)
}

함수에 따라 toastUIEntity:SetEnable() 의 boolean 값을 바꿔줌으로써 토스트메시지가 상황에 따라 출력되거나 숨겨지도록 할 수 있다.

만약 여러개의 토스트메시지를 한번에 띄우거나 숨겨야하는 경우 엔티티의 노출 처리를 효율적으로 관리할 수 있는 계층구조를 활용할 수 있다.

계층 구조를 사용하지 않은 UI 노출 처리는 아래와 같다.

void ShowPopupUI ()
{
    local PopupUIEntity_1 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODImage_1")
    local PopupUIEntity_2 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1")
    local PopupUIEntity_3 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1_1")
    local PopupUIEntity_4 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODText_1")
    local PopupUIEntity_5 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1_1_1")
    PopupUIEntity_1:SetEnable(true)
    PopupUIEntity_2:SetEnable(true)
    PopupUIEntity_3:SetEnable(true)
    PopupUIEntity_4:SetEnable(true)
    PopupUIEntity_5:SetEnable(true)
}

void HidePopupUI ()
{
    local PopupUIEntity_1 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODImage_1")
    local PopupUIEntity_2 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1")
    local PopupUIEntity_3 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1_1")
    local PopupUIEntity_4 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODText_1")
    local PopupUIEntity_5 = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODButton_1_1_1")
    PopupUIEntity_1:SetEnable(false)
    PopupUIEntity_2:SetEnable(false)
    PopupUIEntity_3:SetEnable(false)
    PopupUIEntity_4:SetEnable(false)
    PopupUIEntity_5:SetEnable(false)
}

계층 구조를 사용한 UI 노출 처리는 아래와 같다.

void ShowPopupUI ()
{
    local PopupUIEntity = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODImage_1")
    PopupUIEntity:SetEnable(true)
}

void HidePopupUI ()
{
    local PopupUIEntity = _EntityService:GetEntityByPath("/ui/DefaultGroup/MODImage_1")
    PopupUIEntity:SetEnable(false)
}

혁...신!

UI는 UI Group을 통해서 연관 기능이 있는 UI 엔티티끼리 묶어 관리한다.

예를 들어 체력바는 인벤토리와, 지도는 랭킹과 함께 UI Group으로 묶을 수 있다.

UI Group의 노출 및 숨김 처리도 위에서 이야기한 SetEnable 함수로 설정한다.

void ShowUIGroup_1 ()
{
    local UIGroup_1 = _EntityService:GetEntityByPath("/ui/UIGroup_1")
    UIGroup_1:SetEnable(true)
}

void HideUIGroup_1 ()
{
    local UIGroup_1 = _EntityService:GetEntityByPath("/ui/UIGroup_1")
    UIGroup_1:SetEnable(false)
}

UI Group의 상시 노출을 설정하고자 하는 경우에는 DefaultShow 속성의 값을 true로 설정하자

UI Group에 텍스트 그룹을 추가하는 방법

1. UI Group 편집창에서 새 그룹을 추가하기

2. 기본 도구에서 텍스트 끌어다 추가하기

UITransformComponent 은 배치한 텍스트 박스의 위치와 크기를 설정할 수 있는 컴포넌트이다.

또한 SpriteGUIRendererComponent 의 다양한 속성값을 통해 텍스트박스의 배경색, 배경, 리소스 경로 설정 등 텍스트박스를 예쁘게 꾸며볼 수 있다.

위 텍스트 박스에 이미지를 추가할 수 도있다.

1. 메이커의 UI 버튼을 눌러 UI 에디터로 이동하여 UIGroup에서 해당 그룹으로 이동한다.

2. 좌측의 기본도구에서 이미지를 클릭해 이미지 UI를 추가한다.

3. SpriteGUIRendererComponent의 ImageRUID 프로퍼티의 우측 버튼을 클릭해 Sprite Picker 메뉴를 선택한다.

4. 프로퍼티를 조정해 이미지 UI의 크기와 위치를 설정해준다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 9~ 10 회고

개발자Dongbaek — Wed, 20 Jul 2022 16:21:38 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 3주차 20일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

아뇨

오늘도 블로그를 찾아줘서 고맙고, 반갑다.

반갑습니다

Chapter 9~ 10은 컴포넌트의 활용에 대해서 중점적으로 배우는

매우

중요한 챕터이다.

MOD 개발에 있어서의 컴포넌트는 엔티티의 움직임 및 여러 속성들을 좌지우지 하기에 반드시 반드시 알고있어야 한다.

반드시

// 컴포넌트에 대한 기초 개념과 기본 컴포넌트는 아래 주소를 참고하도록 하자!

https://devdongbaek.tistory.com/131

이번 챕터에서는 여러 컴포넌트들과 해당 컴포넌트의 Property가 어떤 역할을 하는지에 대해서 배웠는데, Chapter 2에서 배우지 않았던 컴포넌트들은 제외하고 한번 이야기 해보자

가보자~!

첫번째로 이야기 해볼 컴포넌트는 MovementComponent 이다. 이름에서 알 수 있듯이 이 컴포넌트는 캐릭터의 움직임에 관여하는 컴포넌트이다.

MovementComponent는 2개의 Property가 존재하는데, 각 Property는 다음과 같다.

InputSpeed : 이동 속도를 조절하는 프로퍼티 (X축 기준)
JumpForce : 점프력을 조절하는 프로퍼티 (Y축 기준)

두번째로 이야기 할 컴포넌트는 WebSpriteComponent 이다. 이 컴포넌트는 웹에 있는 이미지를 가져와서 표시해주는 컴포넌트이다.

WebSpriteComponent는 위와 같은 Property가 존재하는데, 중요한 Property는 다음과 같다.

Color : Sprite에 색깔을 덧씌운다.
FlipX, FlipY : Sprite의 X, 축을 기준으로 반전 여부를 결정한다.
Url : Sprite의 Url이다.

그 다음은 YoutubePlayerWorldComponent이다. 이 또한 이름에서 잘 나타나는데 유튜브 영상을 씬 내에서 불러와 재생시킬 수 있다.

YoutubePlayerWorldComponent는 위와 같은 Property가 존재하는데, 중요한 Property는 다음과 같다.

YoutubePlayerGUIComponent : UI 상에서 표시해줄 때 사용
YoutubePlayerWorldComponent : 월드상에 표시할 때 사용

아래부터는 실 mod 개발에 정말 빈번하게 사용되는 컴포넌트들에 대해서 알아보겠다.

정말 정말 중요하니 다들 집중해주길 바란다.

먼저 입력 관련 컴포넌트들을 알아보겠다.

입력 관련 컴포넌트는 Entity Event Handler 에서 작업한다

아래는 유저가 키보드의 키를 입력했을 때 이벤트를 처리하는 컴포넌트들이다.

KeyDownEvent : 키를 1번 눌렀을 때 발생
KeyHoldEvent : 키를 누르는 동안 발생
KeyReleaseEvent : 키를 길게 눌렀다 뗐을 때 발생
KeyUpEvent : 키를 1번 눌렀을 때 발생

만약 키보드의 'P'를 눌렀을 때의 로그를 출력하는 이벤트를 작성할 때의 예시 코드

유저가 화면을 터치 할 때 이벤트를 처리하는 컴포넌트들이다.

ScreenTouchEvent : 월드상의 화면을 터치, 또는 클릭했을 때 1회 발생하는 이벤트
ScreenTouchHoldEvent : 월드상의 화면을 터치하고 있는 동안 프레임마다 발생하는 이벤트
ScreenTouchReleaseEvent : 터치를 유지하다가 터치를 종료했을 때 1회 발생하는 이벤트
TouchEvent : Entity를 터치했을 때 발생하는 이벤트, 엔티티에 TouchReceiveComponent 컴포넌트가 있어야 이벤트 발생
TouchHoldEvent : Entity를 터치하고 있는 동안 발생하는 이벤트, 엔티티에 TouchReceiveComponent 컴포넌트가 있어야 이벤트 발생, 짧게 터치하면 발생 X
TouchReleaseEvent : Entity를 터치 땠을 때 발생하는 이벤트, 엔티티에 TouchReceiveComponent 컴포넌트가 있어야 이벤트 발생

// 터치를 받는 이벤트를 받는 컴포넌트에 반드시 TouchReceiveComponent 를 추가해주어야 한다.

입력 관련 컴포넌트에는 유저가 특정 키를 누를 때마다 스킬을 사용할 수 있게 해주는 컴포넌트가 있다.

해당 컴포넌트를 Skill Effect라고 하는데, _EffectService 클래스 내부에 이벤트를 컨트롤 할 수 있는 함수가 내장되어 있으며, 주로 PlayEffect() 함수와 PlayEffectAttached() 함수가 개발에 자주 사용된다.

PlayEffect() 함수 -> 이펙트를 고정된 특정 위치에 원하는 크기로 호출한다.

-> 쉽게 말해서 스킬을 썼을 때의 해당 유저 위치에 호출

PlayEffect (string animationClipRUID, Entity instigator, Vector3 position, number zRotation, Vector3 scale, boolean isLoop = False)

animationClipRUID : 호출하려는 이펙트 리소스의 RUID
instigator : 맵 정보를 받아오기 위한 엔티티
position : 이펙트가 호출될 위치 벡터값 입력 파라미터
zRotation : 회전 값
scale : 호출될 이펙트의 크기 벡터값 (Vector3)
isLoop
- true : 이펙트 무한 재생
- false : 이펙트 한 번 재생

PlayEffectAttached() 함수 -> 이펙트 호출, 호출될 이펙트의 부모 엔티티 선정, 부모의 위치를 기준으로 호출될 위치 설정을 하는 함수

-> 쉽게 말해서 스킬을 쓴 유저의 위치를 따라다니며 호출

animationClipRUID : 호출하려는 이펙트 리소스의 RUID
parentEntity : 호출될 이펙트의 부모가 될 엔티티
localPosition : 부모 엔티티의 position 기준, 얼마만큼 떨어진 곳에서 호출할 것인지에 대한 위치 벡터값 (Vector3)
localZRotation : 부모 엔티티의 회전값을 기준, 회전 값 입력
localScale : 호출될 이펙트의 크기 벡터값 (Vector3)
isLoop
- true : 이펙트 무한 재생
- false : 이펙트 한 번 재생

입력 관련 컴포넌트에는 또한 카메라를 조정할 수 있는 컴포넌트가 존재한다.

바로 CameraComponent이다.

기본적으로 Camera는 엔티티, 즉 내 캐릭터를 잡아주고 있다. CameraComponent는 카메라로 목적지가 어디인지 보여주고 다시 내 캐릭터를 잡아주는 함수이다.

Camera를 다룬 이벤트들도 존재한다.

CameraSwitchEvent : 카메라가 비추는 대상이 전환될 때 발생하는 이벤트
CameraZoomEndEvent : 카메라의 줌 변경이 완료된 후 발생하는 이벤트

입력 관련 컴포넌트에는 또한 포탈을 조정할 수 있는 컴포넌트가 존재한다.

이는 PortalComponent이다.

Portal은 출발지와 목적지가 반드시 한 쌍으로 존재해야 하고, Portal은 기본적으로 방향 키 위를 누를 경우 이동할 수 있다.

PortalComponent에 중요한 Property가 존재한다.

PortalEntityRef : PortalComponent를 가진 Entity를 목적지로 설정한다. 설치 후 게임을 저장해야 목록에 노출된다.

Portal를 다룬 이벤트들도 존재한다.

PortalUseEvent : 플레이어가 포탈을 이용할 때 발생하는 이벤트

오늘의 사소한 깨달음

- 컴포넌트 뿐만 아니라 해당 컴포넌트의 property와 Service에 대해서 더 공부를 해야겠다.
- Service란 말 그대로 기능을 제공한다. Service의 원하는 기능을 객체 형식으로 가져와서 멤버 변수를 넣어주면 된다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 8 회고

개발자Dongbaek — Tue, 19 Jul 2022 18:41:06 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 3주차 19일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

오늘도 사랑합니다

오늘은 Chapter 8. Event와 컴포넌트 확장에 대해 배웠다.

MOD에서는 Event 처리를 위해 Entity Event System을 제공한다.

이벤트는 특정 상황에서만 발생된다.

아래는 Event System에 해당하는 3가지 구성 요소이다.

Event : 로직 상에서 사건의 발생을 의미 (Event의 종류의 식별 정보, 추가 정보 소유)
- ex) 공격을 받은 사건
Handler : 해당 Event를 받았을 때 처리하는 행동의 주체
- ex) 플레이어가 공격을 받았을 때 호출되는 함수
Sender : 해당 이벤트를 발송하는 객체
- AttackComponent에서 이벤트를 발송했으면 AttackComponent가 Sender이다.

이해하기 쉽게 우리가 만들었던 코드를 들고왔다.

위 코드를 예시로 용어를 좀 더 쉽게 이해해보자

Event : 엔티티간 충돌이 있어난 사건을 의미한다.

Handler : 이벤트가 일어났을 때 호출 될 HandlerTriggerEnterEvent를 의미한다.

Sender : 해당 이벤트를 발송하는 객체는 self.Entity인 유저가 될 것이다.

MOD에서 사용하는 Event 시스템의 장단점은 아래와 같다.

장점
- 다른 component나 기능 단위에서 결합성이 떨어진다.
- 행위에 대한 액션 추가 희망 시 행위 수행하는 곳 수정 없이 추가 가능하다.
- 다른 Component의 정보를 필요로 하지 않는다.
단점
- 사건 발생 시 전체적 플로우 찾기 어렵다 (각각 처리하는 로직으로 인해 실행되는 시점에서 알 수 없다)
- 디버깅이 어렵다.
- 순차적 행위 수행이 어렵다.

이번에는 핸들러의 등록 구조에 대해서 알아보자

각 엔티티들은 컴포넌트들을 포함하고 있다.

중학생 형만 하더라도 수많은 컴포넌트들을 지니고 있다.

엔티티 이벤트 시스템은 다음과 같이 동작한다.

가장 먼저 컴포넌트는 각 엔티티를 중계자로 사용할 수 있으며, 각 컴포넌트는 엔티티를 통해 핸들러를 등록한다. (이벤트 발생 역시 엔티티를 통해 가능하다.)

위 말을 Bbing Component로 설명해보겠다.

Bbing Component는 DefaultUser 엔티티(Self)를 중계자로 사용하며, DefaultUser를 통해 핸들러인 HandlerTriggerEnterEvent 함수를 등록한다.

sender 역시 엔티티를 통해 이벤트를 발생하는 것이 가능하며, 이 때 엔티티는 Handler들에게 해당 이벤트를 전송하는 역할을 한다.

정리를 해보자면, 어떤 event를 감지하였을 때 이것을 처리하는 부분을 component내의 로직에 넣는다. 그리고 이벤트 수신 등록을 register, addListener 등으로 하며, MOD에서는 entity에 등록을 하는 구조이다.

엔티티끼리 이벤트를 주고받을 때에 대해서 알아보자

엔티티끼리 이벤트를 주고 받는 경우는 2가지가 있다.

1. 같은 엔티티에서 이벤트를 주고 받을 때

짤 출처 : 이승훈님

2. 다른 엔티티끼리 이벤트를 주고 받을 때

먼저 같은 엔티티에서 이벤트를 주고 받을 때의 프로세스를 알아보자

component1이 특정 타이밍에 의해 엔티티로 발송
로그 이벤트를 수신하겠다고 등록한 컴포넌트들에게 이벤트 발송
- 로그 이벤트를 객체로 불러온 컴포넌트들
해당 컴포넌트들은 이벤트를 받아서 처리

Ex) component1에서 이벤트 발생 시, component3의 이벤트를 실행시키고 싶을 때를 가정한다. 두 component간에 연관이 없기 때문에 component에서 바로 호출하지 않고 엔티티를 통해 호출하는 구조이다.

-> 이러한 이유로 위에서 컴포넌트는 엔티티를 중계자로 활용한다고 말했던 것이다.

그럼 다른 엔티티에서 이벤트를 주고 받을 때의 프로세스를 알아보자

신호를 보내는 엔티티 쪽에서 component들이 이벤트 발송
받는 엔티티 쪽에서 신호를 받고 이벤트 수행

위 프로세스를 구현하는 방법을 이야기해보자!

1. Entity1의 Component1에서 이벤트 등록

2. Entity2의 Component2에서 Entity1로 이벤트 발송

Ex) Entity1이 Entity2 쪽으로 이벤트를 쏘면 Component가 수신해서 Component 안의 로그 메시지가 출력 되는 구조이며, 특히 Map Entity와 World Entity는 서로 Event를 주고받는 경우가 많아 자주 사용된다.

이벤트 처리는 아래의 순서로 이루어진다.

이벤트를 처리할 컴포넌트 & 엔티티 생성
핸들러 로직 추가
- 핸들러 로직이 이루어지는 방법
  1. Entity Event Handler 추가
  2. 핸들러 상단 이벤트 중계자 설정
  3. 이벤트 처리 로직
이벤트 발생 로직 추가

위 순서를 중학생 형 Entity에서 Bbing Component를 생성하는 걸 예로 들어보자

1. 중학생 형 엔티티에 이벤트를 처리할 Bbing Component를 생성

2. 충돌을 감지했을 때 실행될 HandleTriggerEnterEvent 핸들러 로직 추가

중계자 설정하는 방법

3. 충돌 이벤트 발생시 실행될 로직 추가

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 7 회고

개발자Dongbaek — Tue, 19 Jul 2022 00:57:19 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 3주차 18일 회고

// 해당 글은 멋쟁이 사자처럼 공동 학습 교안을 바탕을 작성되었습니다.

예비군 다녀왔습니다.

오늘은 Chapter 7. 네트워크에 대해 공부하였다.

공부한 것을 나누며 이야기 하기 전에 앞서서 기본적인 단어 정리에 대해서 정리해보겠다.

깔 끔

클라이언트 : 접속된 각각의 유저 ex) MOD를 플레이 하는 유저

서버 : 클라이언트의 요청을 받는 서버 ex) MOD 서버

동기화 : 어느 한 쪽의 값이 달라졌을 때 양쪽의 값을 모두 바꾸는 행동을 취하는 것

단어 정리는 이쯤하고 MOD 네트워크 구조에 대해서 알아보도록 하자

MOD는 기본적으로 서버-클라이언트 모델을 지원하고 있다.

서버-클라이언트 모델에 대해서 자세히 이야기해보자면

서버-클라이언트 모델은 서버는 기본적으로 하나이고, 여러 클라이언트를 가지고 있다.

하나의 메이플 서버에 여러 유저가 동시접속하고 있는 것을 생각하면 이해하기 쉬울 것이다.

또한 서버에서 특정 Property 값을 바꾸면, 그 Property를 가지고 있는 클라이언트의 Property도 전부 값이 변한다.

그러나 클라이언트에서는 독자적으로 Property 값을 변경해도 다른 클라이언트나 서버에 영향을 미치지 않는다.

여기서 하나의 예시를 들어보자.

우리는 인기 많은 사냥터에 가서 사냥할 생각에 신나있었다.

그런데 맵에 도착해보니, 어느 유저가 해당 사냥터는 본인의 자리라고 말을 하는 것을 듣게 되었다.

화가난 우리는 상대방에게 그런게 어딨냐 했지만, 상대적으로 약한 우리는 그저 인기도를 내리고 도망가는 것 밖에 방법이 없었다.

자리요@@@@@@@

그런데 인기도가 클라이언트 Property일 뿐이면, 우리가 내렸다 하더라도 서버의 Property에 영향을 끼치지 못하므로, 우리의 일격(?)은 물거품이 될 것이다.

화가 나

그러나 인기도가 서버의 Property라면 우리의 공격은 성공적일 것이다.

위에서 배운 개념들을 더해 MOD의 핵심 네트워크 개념들을 더 배워보자

가즈아

위에서 이야기 했듯이 서버에서는 특정 Property의 값을 바꾸면 갖고 있는 클라이언트의 Property 또한 전부 값이 변경되는 반면 클라이언트에서는 Property의 값을 바꿔도 서버의 Property에 영향을 미치지 않는다.

만약 인기도가 클라이언트 Property이고, 모든 유저가 상대방의 인기도를 동시에 내렸다고 해보자.

서버-클라이언트는 1:n 관계이기 때문에 서버는 펑 터져버리고 말 것 이다.

그렇기에 동기화는 서버 -> 클라이언트 단방향으로 진행된다.

MOD에서는 Property에 동기화 옵션을 설정할 수 있게 해준다.

이를 Property 실행제어라 말한다.

동기화 옵션은 아래와 같다.

[Sync] : 동기화가 되는 property
[None] : 동기화 되지 않는 Property

또한 Property의 타입들도 설정할 수 있는데, 일부 타입(any, table)은 동기화가 지원되지않는다.

property를 우클릭하면 위 창이 뜬다.

또 MOD에서는 Function 실행 제어를 지원한다.

Function은 호출한 쪽이 서버인지 클라이언트인지에 따라 동작하는 공간이 다르다. 따라서 실행 제어를 통해 공간을 활성화 시켜주어야 한다.

공간을 활성화 해준다는 것은 해당 Function이 특정한 속성을 지니게 하는 것이다.

Function setting으로 들어가면 된다.

Function 공간 활성화 옵션은 아래와 같습니다.

Client : 서버가 클라이언트의 함수를 호출하면 서버와 연결된 클라이언트들에게 함수 호출을 요청하고, 연결된 클라이언트들에 있는 함수가 실행된다.
- 호출시 클라이언트에서 실행된다.
ClientOnly : 클라이언트에만 불릴 수 있으며 서버에서는 부를 수 없다.
Server : 클라이언트 쪽에서 서버의 함수를 호출하면 서버 쪽에 신호를 보내 서버 안에서 함수가 실행되게 한다.
- 호출시 서버에서 실행된다.
ServerOnly : 서버에만 불릴 수 있고, 클라이언트에서는 부를 수 없다. 대부분의 로직는 서버에서 서버 기준으로 짜게 된다. 즉, 로직은 주로 서버 위주의 행위를 많이 하게 됩니다.
Multicast : 서버와 클라이언트 양쪽 모두 실행한다.

아래 코드는 위 공간 활성화 옵션들을 잘 설명해줄 수 있는 예시 코드이다.

MyFirstComponent {
		Property:
		Function:
				void OnBeginPlay()
				{
						log("BEGIN PLAY")
						wait(2)
						self:Server()  -- 1. 서버가 서버 메시지를 뿌립니다.
						self:Client("HAHAHA")  -- 2. 클라이언트에서 메시지를 뿌려달라고 요청 후 바로 다음을 실행합니다.
						log("END")
				
				void Client( string arg1 )  -- 3. 클라이언트에 도착하면 클라이언트가 메시지를 받은 순간 요청을 실행합니다.
				{
						log("CLIENT" .. arg1)
				}

				void Server()
				{
						log("SERVER")
				}

			
}

위 코드의 프로세스를 따라가면서 이야기해보자

1. log("BEGIN PLAY")을 통해 "BEGIN PLAY"라는 문자열을 log에 출력한다.

2. wait(2)를 통해서 2초 후에 다음 명령어를 실행한다.

3. self:Server()를 통해 void Server() 함수를 호출한다.

서버( Server() )가 서버( Server 공간 활성화 옵션 )에 메세지를 뿌린다.

4. self:Client ( "문자열" )를 통해 void Client( string arg1 ) 함수를 호출한다.

클라이언트( Clien() )가 클라이언트( Clien 공간 활성화 옵션 )에 메세지를 뿌린다.

위 코드 실행 결과

서버에서 요청했을 때 클라이언트까지 요청이 도달하는 시간이 서버가 다음 코드를 실행하는 시간보다 짧으면 클라이언트가 먼저 찍히게 된다. 즉, 요청이 클라이언트까지 도달하지 못했기 때문에 다음 코드인 end가 먼저 찍히고 클라이언트가 찍힌다.

*wait(2)을 써주지 않았을 때 CLIENT 뒤에 파라미터로 받은 문자열이 출력되지 않는 현상 발생하는 이유

답 : 서버에서 엔티티를 생성하고 클라이언트에도 엔티티가 생성되기까지 시간이 걸린다. 클라이언트에서 엔티티가 생성되는 도중에 서버에서 엔티티의 값을 넣어 전송하면 클라이언트에서 값을 받지 못하는 현상이 발생한다. 이를 타이밍 이슈라고 한다.

MOD는 Server only 에서 이야기 했듯이 MOD의 로직 대부분은 서버 기반으로 돌아가며,

서버에서 로직의 흐름을 관리하고 중간중간 변경된 사항을 각 클라이언트에 전달하는 시스템이다.

특정 클라이언트 안에서만 생성되는 엔티티의 대표적인 예시들

UI
입력
effect - effect의 경우 보통 서버로 제어하는데 특정 클라이언트에서만 연출하고 싶을 땐 로컬 엔티티를 사용한다.
최적화 - 서버에 엔티티가 너무 많을 때 비용 때문에 최적화 시 로컬 엔티티를 사용한다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 공동 월드 회고

개발자Dongbaek — Fri, 15 Jul 2022 23:07:52 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 15일 회고

짝짝

아래는 지난 회고록들로 쉽게 갈 수 있는 링크입니다.

Chapter 1~4 회고록

https://devdongbaek.tistory.com/132

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 1~4 회고

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 1주차 11일 회고 부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습..

devdongbaek.tistory.com

Chapter 5 회고록

https://devdongbaek.tistory.com/136

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 5 회고

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 12일 회고 부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습..

devdongbaek.tistory.com

Chapter 6 회고록

https://devdongbaek.tistory.com/137

Chapter 워크스페이스 회고록

https://devdongbaek.tistory.com/144

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 워크 스페이스 회고

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 14일 회고 부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습..

devdongbaek.tistory.com

우리는 저번 주 그룹을 만드는 방법과 멤버들을 초대하는 방법에 대해서 배웠다.

아마 몇몇 분들은 멤버를 초대하는 부분에서 많이들 막혔을 거라 생각이 든다.

수능 수학 29번급 난이도

필자야 워낙 친구들이 많으니 어렵지는 않았다ㅋㅋㅋㅋ

정말로 ㅋㅋㅋㅋ...

조금은 어려웠을지ㄷ...?

ㅠ

딴 소리는 이쯤하고, 오늘은 공동 월드를 제작하는 방법을 함께 배워보겠다.

1. 먼저 그룹 월드를 시작해야 한다.

홈에서 만들기에 들어간 다음 월드(그룹) 선택 후 이어서 만들기를 누르면 공동 월드로 들어가진다.

어제는 내가 시험삼아 아래의 박진영만 만들어놨었는데, 오늘 보니 친구들이 늘어나있다.

왼쪽은 XX님이 어제 먹은 뿌링클 친구이고, 오른쪽 종이 뭉치는 XX님이 남겨놓으신 편지이다.

우리팀 정말 귀엽지 않은가..??

소중해...

카와이..

아무리 우리팀이 귀엽다 하더라도

나의 귀여움이 살짝 더 강하긴 한 것 같다.

죄송합니다.

어제 잠깐 같이 협업을 진행했었는데 불편한 점들이 있었다.

가명으로 뿌링클 팀원과 휴지 팀원이 있다고 가정해보자

만약 뿌링클 팀원이 편집을 진행중이면, 휴지 팀원은 해당 Map을 편집할 수 없다.

뿌링클 팀원이 편집을 마치고, ctrl + s를 눌러서 Check-in을 눌러주어야만 휴지 팀원이 편집을 할 수 있게 된다.

아쉽다 ㅠ

단 맵마다 편집자가 다르게 편집을 할 수 있기에

맵 A를 뿌링클이 편집하고, 맵 B를 휴지가 편집한다면 동시에 편집할 수 있다.

이제 그룹장의 권력..

아니 권한에 대해서 설명해보겠다.

1. 그룹장은 그룹 내 새로운 월드를 생성할 수 있다.

2. 시작맵을 변경할 수 있다.

3. 버전관리를 할 수 있다.

[File] → [Revisions]에 들어가면 버전관리를 할 수 있다.

엥 생각보다 권력, 아니 권한이 없다고 생각할 수 있다.

핵심적인 권한이 하나 있다.

그룹장 : ㅋㅋㅋㅋ 저 그룹원 재밌네 그래

그룹장 : 쳐내

그룹원 : ?

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

DRF JWT 인증

개발자Dongbaek — Fri, 15 Jul 2022 17:23:02 +0900

전 강의에서 배운 Django의 기본 Token은 랜덤 문자열로 구성되어 있기에 Token을 통해서 어떤 유저인지 알 수 없고, Token 유효기간도 없어서 위험하다.

이러한 기본 Token의 단점을 JWT를 통해서 보완해보자.

Token 인증과 JWT 인증

DRF의 기본 Token

단순한 랜덤 문자열

각 User와 1:1 매칭
유효기간이 없습니다.
Token을 받았을 때 어떤 유저의 Token인지 알 수 없음

>>> import binascii
>>> import os
>>> binascii.hexlify(os.urandom(20)).decode()
'ec90f85721dc5f75b6eec47d199e3476c301633f'

JWT

데이터베이스를 조회하지 않아도, 로직만으로 인증이 가능 -> JWT 만으로 JSON 형태로 유저 정보를 담고있음.
포맷 : "헤더.내용.서명"
- 서버에서 토큰 발급 시에 비밀키로 서명을 하고, 발급 시간및 원하는 정보를 저장 -> 비밀키는 절대 노출되어서는 안된다.
- 서명은 암호화가 아닙니다. 누구라도 열어볼 수 있기에, 보안성 데이터는 넣지 말고, 최소한의 필요한 정보만 넣기.
Claim : 담는 정보의 한 조각. key/value형식
- djangorestframework-jwt에서는 Payload에 user_id, username, email 이름의 claim을 사용
위변조가 불가 → 비밀키를 소중히
- 장고에서는 settings.SECRET_KEY를 활용하거나, 별도로 JWT_SECRET_KEY 설정을 합니다.
갱신(Refresh) 메커니즘을 지원
- JWT는 만료시간이 있고, 갱신을 지원한다.
- Token 유효기간 내에 갱신하거나, usernames/password를 통해 재인증 (Token 유효기간 내에 갱신 시, username/password가 아닌 기존의 Token을 이용해 갱신이 가능)
이미 발급된 Token을 폐기(Revoke)하는것은 불가

Token과 JWT

일반 토큰 예시)

8df73dafbde4c669dc37a9ea7620434515b2cc43

JSON Web Token 예시)
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoxLCJ1c2VybmFtZSI6ImFza2RqYW5nbyIsImV4cCI6MTUxNTcyMTIxMSwiZW1haWwiOiIifQ.Zf_o3S7Q7-cmUzLWlGEQE5s6XoMguf8SLcF-2VdokJQ

Header(헤더)를 base64 인코딩
Payload(내용)를 base64 인코딩
Signature(서명) = Header/Payload를 조합하고, 비밀키로 서명한 후, base64 인코딩

Payload를 변조해서 서버로 보냄 → 서버에서는 Signature 와 Payload값이 일치하지 않으므로, 무결하지 않다고 판단 후 거부가 가능하다.

>>> from base64 import b64decode
>>> b64decode('eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9')
b'{"typ":"JWT","alg":"HS256"}'
>>> b64decode('eyJ1c2VyX2lkIjoxLCJ1c2VybmFtZSI6ImFza2RqYW5nbyIsImV4cCI6MTUxNTcyMTIxMSwiZW1haWwiOiIifQ==')
b'{"user_id":1,"username":"askdjango","exp":1515721211,"email":""}'

JWT를 해독한 결과
- 첫번째 b는 헤더, 두번째 b는 내용이다.

Token은 안전한 장소에 보관하기

일반 Token / JWT 토큰 여부에 상관없습니다.
스마트폰 앱은, 설치된 앱 별로 안전한 저장공간이 제공되지만, 웹브라우저에는 없습니다.
- Token은 앱 환경에서만 권장하기도 합니다.
- 웹 클라이언트 환경에서는 세션 인증이 나은 선택일 수 있습니다. 단 장고/웹클라이언트가 같은 호스트명을 가져야 함.
통신은 필히 https !!!
- Let's Encrypt(https보급을 위해 등장한 무료 인증 기관)에서 SSL인증서를 발급받아 서비스하자

djangorestframwork-simplejwt

https://github.com/jazzband/djangorestframework-simplejwt

GitHub - jazzband/djangorestframework-simplejwt: A JSON Web Token authentication plugin for the Django REST Framework.

A JSON Web Token authentication plugin for the Django REST Framework. - GitHub - jazzband/djangorestframework-simplejwt: A JSON Web Token authentication plugin for the Django REST Framework.

github.com

https://jiaaan90.tistory.com/152

[DRF] JWT (simple jwt)

JWT (Json Web Token) 인증 개발 경험에 대해 적어 보려고 한다. 처음에 구현 했던 방식은 djangorestframework-jwt 를 사용 했었는데 https://pypi.org/project/djangorestframework-jwt/ djangorestframework-jw..

jiaaan90.tistory.com

https://medium.com/chanjongs-programming-diary/django-rest-framework-drf-%ED%99%98%EA%B2%BD%EC%97%90%EC%84%9C-jwt-%EA%B8%B0%EB%B0%98-authentication-%EC%84%B8%ED%8C%85%ED%95%98%EA%B8%B0-with-simplejwt-%EC%B4%88%EA%B8%B0-%ED%99%98%EA%B2%BD-%EC%84%B8%ED%8C%85-1-e54c3ed2420c

Django-Rest-Framework(DRF)로 JWT 기반 Authentication 세팅하기(with simplejwt) — 초기 환경 세팅(1)

앞서 포스팅했던 소셜 로그인 구현에서 생각보다 많은 개발자 분들이 봐주신 덕분에 상위노출도 되어 기뻤지만, 이전 코드를 다시 보니 많이 부족하단 생각이 들었다. 특히 JWT 부분에서 이해력

medium.com

설치

pip3 install djangorestframework-simplejwt

세팅

# 프로젝트/settings.py
from datetime import timedelta

INSTALLED_APPS = [
    # ...
    'rest_framework_simplejwt',
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        # 'rest_framework.authentication.BasicAuthentication',
        # 'rest_framework.authentication.SessionAuthentication',
        # 'rest_framework.authentication.TokenAuthentication',
        'rest_framework_simplejwt.authentication.JWTAuthentication', # 추가
    ],
}

 SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': False,
    'UPDATE_LAST_LOGIN': False,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUDIENCE': None,
    'ISSUER': None,
    'JWK_URL': None,
    'LEEWAY': 0,

    'AUTH_HEADER_TYPES': ('Bearer',),
    'AUTH_HEADER_NAME': 'HTTP_AUTHORIZATION',
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',
    'USER_AUTHENTICATION_RULE': 'rest_framework_simplejwt.authentication.default_user_authentication_rule',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
    'TOKEN_USER_CLASS': 'rest_framework_simplejwt.models.TokenUser',

    'JTI_CLAIM': 'jti',

    'SLIDING_TOKEN_REFRESH_EXP_CLAIM': 'refresh_exp',
    'SLIDING_TOKEN_LIFETIME': timedelta(minutes=5),
    'SLIDING_TOKEN_REFRESH_LIFETIME': timedelta(days=1),
}



# 프로젝트/urls.py

from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
    TokenVerifyView
)

urlpatterns = [
    # ...
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
    path('api/token/verify/', TokenVerifyView.as_view(), name='token_verify'),
]

rest_framework_jwt의 뷰 구현

from rest_framework import generics, status
from rest_framework.response import Response

from . import serializers
from .authentication import AUTH_HEADER_TYPES
from .exceptions import InvalidToken, TokenError

class TokenViewBase(generics.GenericAPIView):
    permission_classes = ()
    authentication_classes = ()

    serializer_class = None

    www_authenticate_realm = 'api'

    def get_authenticate_header(self, request):
        return '{0} realm="{1}"'.format(
            AUTH_HEADER_TYPES[0],
            self.www_authenticate_realm,
        )

    def post(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)

        try:
            serializer.is_valid(raise_exception=True)
        except TokenError as e:
            raise InvalidToken(e.args[0])

        return Response(serializer.validated_data, status=status.HTTP_200_OK)

class TokenObtainPairView(TokenViewBase):
    """
    Takes a set of user credentials and returns an access and refresh JSON web
    token pair to prove the authentication of those credentials.
    """
    serializer_class = serializers.TokenObtainPairSerializer

token_obtain_pair = TokenObtainPairView.as_view()

class TokenRefreshView(TokenViewBase):
    """
    Takes a refresh type JSON web token and returns an access type JSON web
    token if the refresh token is valid.
    """
    serializer_class = serializers.TokenRefreshSerializer

token_refresh = TokenRefreshView.as_view()

class TokenObtainSlidingView(TokenViewBase):
    """
    Takes a set of user credentials and returns a sliding JSON web token to
    prove the authentication of those credentials.
    """
    serializer_class = serializers.TokenObtainSlidingSerializer

token_obtain_sliding = TokenObtainSlidingView.as_view()

class TokenRefreshSlidingView(TokenViewBase):
    """
    Takes a sliding JSON web token and returns a new, refreshed version if the
    token's refresh period has not expired.
    """
    serializer_class = serializers.TokenRefreshSlidingSerializer

token_refresh_sliding = TokenRefreshSlidingView.as_view()

class TokenVerifyView(TokenViewBase):
    """
    Takes a token and indicates if it is valid.  This view provides no
    information about a token's fitness for a particular use.
    """
    serializer_class = serializers.TokenVerifySerializer

token_verify = TokenVerifyView.as_view()

class TokenBlacklistView(TokenViewBase):
    """
    Takes a token and blacklists it. Must be used with the
    `rest_framework_simplejwt.token_blacklist` app installed.
    """
    serializer_class = serializers.TokenBlacklistSerializer

token_blacklist = TokenBlacklistView.as_view()

# 위 코드들이 모두 정상 처리 시에 아래 포맷의 응답을 보냄

{
    "token": token,
    "user": user
	
}

HTTPie를 통한 JWT 발급

인증에 실패할 경우, "400 Bad Request" 응답
모든 연결에서는 서버와 HTTPS 통신을 권장
발급받은 JWT Token을 jwt.io 서비스를 통해 검증해보세요

쉘> http POST http://서비스주소/api-jwt-auth/ username="유저명" password="암호"
{
    "token": "인증에 성공할 경우, 토큰응답이 옵니다."
}

쉘> http POST http://서비스주소/api-jwt-auth/verify/ token="토큰"
{
    "token": "검증에 성공할 경우, 검증한 토큰 응답이 옵니다."
}

발급받은 JWT Token으로 포스팅 목록 API 요청

DRF Token에서는 인증헤더 시작문자열로 Token을 썼지만, 이제 JWT 사용.
매 요청시마다 인증을 수행합니다.

쉘> http http://서비스주소/post/ "Authorization: Bearer {{토큰}}"  # djangorestframework-simplejwt

JWT Token 유효시간이 지났다면?

JWT Token 유효기간 내에 갱신을 해야만 합니다.
- 유효기간이 지난 Token은 아래와 같이 "401 Unauthorized" 응답
- 유효기간 내에는 Token만으로 갱신 가능
- 유효기간이 지나면 다시 username/password를 통해 인증받아야만 합니다.
유효기간
- settings.JWT_AUTH의 JWT_EXPIRATION_DELTA참조 → 디폴트 5분

쉘> http http://서비스주소/post/ "Authorization: Bearer 토큰"`
HTTP/1.0 401 Unauthorized
{
    "detail": "Signature has expired."
}

JWT Token 갱신받기

Token 유효기간 내에만 가능
settings.JWT_AUTH의 JWT_ALLOW_REFRESH 설정은 디폴트 False
- True 설정에서만 갱신 지원. False인 경우에는 orig_iat 필드를 찾을 수 없다는 응답

쉘> http POST http://서비스주소/api/token/refresh/ refresh="토큰"
{
    "token": "갱신받은 JWT 토큰"
}

DRF Token인증 적용하기

개발자Dongbaek — Fri, 15 Jul 2022 16:35:51 +0900

DRF에서 지원하는 인증

rest_framework.authentication.SessionAuthentication

웹 프론트엔드와 장고가 같은 호스트를 쓴다면, 세션 인증을 사용할 수 있습니다.(nginx 등 활용)
외부 서비스 / 앱에서 세션 인증을 사용할 수 없다. // 안드로이드나 React등에서 사용할 수 없다.

rest_framework.authentication.BasicAuthentication

외부 서비스/앱에서 매번 username/password를 넘기는 것은 보안상 위험하고, 하면 안된다.

rest_framework.authentication.TokenAuthentication

초기에 username/password로 Token을 발급받고, 이 Token을 매번 API요청에 담아서 보내어 인증을 처리
다폴트로 설정되어있지 않기에 설정을 해주어야 함, 추천(세션, 토큰)

Token

Token 모델

https://github.com/encode/django-rest-framework/blob/master/rest_framework/authtoken/models.py

GitHub - encode/django-rest-framework: Web APIs for Django.

Web APIs for Django. . Contribute to encode/django-rest-framework development by creating an account on GitHub.

github.com

User모델과 1:1 관계
각 User별 Token은 수동으로 생성해줘야 합니다. -> Token 모델 객체를 따로 세팅해줘야 한다.
Token은 User별로 유일하며, Token만으로 인증을 수행합니다.

class Token(models.Model):
    key = models.CharField(_("Key"), max_length=40, primary_key=True)
    user = models.OneToOneField(
            settings.AUTH_USER_MODEL, related_name='auth_token',
            on_delete=models.CASCADE, verbose_name=_("User"))
            created = models.DateTimeField(_("Created"), auto_now_add=True)

    class Meta:
        abstract = 'rest_framework.authtoken' not in settings.INSTALLED_APPS

    def save(self, *args, **kwargs):
        if not self.key: # self.key에 값이 없으면, 즉 유저가 Token이 없다면 Key 필드에 랜덤 문자열을 지정.
            self.key = self.generate_key()
        return super().save(*args, **kwargs)

    def generate_key(self):
        return binascii.hexlify(os.urandom(20)).decode()

    def __str__(self):
        return self.key

Token 생성

방법 1) ObtainAuthToken 뷰를 통한 획득 및 생성 -> URL Pattern 매핑 필요

# rest_framework/authtoken/views.py
class ObtainAuthToken(APIView):
    def post(self, request, *args, **kwargs):  # post 요청일 때
        # ...
        # 토큰, 생성여부(bool 반환)
        token, created = Token.objects.get_or_create(user=user) # 유저가 있으면 가져오고, 없으면 토큰을 생성한다.
        return Response({'token': token.key})

ObtainAuthToken 내부 코드

class ObtainAuthToken(APIView):
    throttle_classes = ()
    permission_classes = ()
    parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,)
    renderer_classes = (renderers.JSONRenderer,)
    serializer_class = AuthTokenSerializer
    if coreapi is not None and coreschema is not None:
        schema = ManualSchema(
            fields=[
                coreapi.Field(
                    name="username",
                    required=True,
                    location='form',
                    schema=coreschema.String(
                        title="Username",
                        description="Valid username for authentication",
                    ),
                ),
                coreapi.Field(
                    name="password",
                    required=True,
                    location='form',
                    schema=coreschema.String(
                        title="Password",
                        description="Valid password for authentication",
                    ),
                ),
            ],
            encoding="application/json",
        )

    def post(self, request, *args, **kwargs):
        serializer = self.serializer_class(data=request.data,
                                           context={'request': request})
        serializer.is_valid(raise_exception=True)
        user = serializer.validated_data['user']
        token, created = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})


obtain_auth_token = ObtainAuthToken.as_view()

방법 2) Signal을 통한 자동 생성 -> 일종의 콜백과 같이 동작

from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token

@receiver(post_save, sender=settings.AUTH_USER_MODEL)  # 유저 모델을 지정해서 해당 모델이 save가 될 때 호출
def create_auth_token(sender, instance=None, created=False, **kwargs): # created 인자를 받는다.
    if created:  # create / update 모두 save이기 때문에, created 일때만 참일 때 동작하도록 수정
        Token.objects.create(user=instance)

방법 3) Management 명령을 통한 생성

# 본 명령은 생성된 Token을 변경하지 않습니다. 필수는 아님
python3 manage.py drf_create_token <username>

# 강제로 Token 재생성하기
python3 manage.py drf_create_token -r <username>

Token 획득

Settings에 설정하기

INSTALLED_APPS = [
    # Django Apps
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Third-Party Apps
    'rest_framework',
    'rest_framework.authtoken',  # <-- Here

    # Local Apps (Your project's apps)
    'myapi.core',
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',  # <-- And here
    ],
}

obtain_auth_token을 노출하기

# settings.py
INSTALLED_APPS = [
    # ...
    'rest_framework.authtoken',
]

# python manage.py migrate

# accounts/urls.py
from rest_framework.authtoken.views import obtain_auth_token

urlpatterns += [
    path('api-token-auth/', obtain_auth_token),
]

account 프로젝트에 설정하는 것을 추천한다.
반드시 migrate를 해주어야 한다.

HTTPie를 통해 Token을 획득하기

쉘> http POST http://주소/accounts/api-token-auth/ username="유저명" password="암호"
HTTP/1.0 200 OK
Allow: POST, OPTIONS
Content-Type: application/json
Date: Fri, 01 Dec 2017 06:49:35 GMT
Server: WSGIServer/0.2 CPython/3.6.1
{
"token": "9cdd705c0a0e5adb8671d22bd6c7a99bbacab227"
}

위 토큰을 통해 요청시 더 이상 username과 password를 넘기지 않아도 된다.

Token과 HTTPie 활용 (Bash)

export HOST="http://localhost:8000"
export TOKEN="9cdd705c0a0e5adb8671d22bd6c7a99bbacab227"

# Post List
http GET $HOST/api/post/ "Authorization: Token $TOKEN"

# Post Create
http POST $HOST/api/post/ "Authorization: Token $TOKEN" message="hello"

# Post Create with Photo
http --form POST $HOST/api/post/ "Authorization: Token $TOKEN" message="hello" photo@"f1.jpg"

# Post#16 Detail
http GET $HOST/api/post/16/ "Authorization: Token $TOKEN"

# Post#16 Update
http PATCH $HOST/api/post/16/ "Authorization: Token $TOKEN" message="patched"
http PUT $HOST/api/post/16/ "Authorization: Token $TOKEN" message="updated"

# Post#16 Delete
http DELETE $HOST/api/post/16/ "Authorization: Token $TOKEN"

파이썬에서의 처리

import requests  # pip install requests

HOST = 'http://localhost:8000'
res = requests.post(HOST + '/api-token-auth/', {
    'username': '유저명', # FIXME: 기입해주세요.
    'password': '암호', # FIXME: 기입해주세요.
})
res.raise_for_status()

token = res.json()['token']
print(token)

"""이제 인증이 필요한 요청에는 다음 헤더를 붙여주세요"""
headers = {
    'Authorization': 'Token ' + token, # 필히 띄워쓰기
}

header에 토큰을 담아서 보냄

# Post List
res = requests.get(HOST + '/api/post/', headers=headers)
res.raise_for_status()
print(res.json())

# Post Create
data = {'message': 'hello requests'}
res = requests.post(HOST + '/api/post/', data=data, headers=headers)
print(res)
print(res.json())

# Post Create with Photo
files = {'photo': open('f1.jpg', 'rb')}
data = {'message': 'hello requests'}
res = requests.post(HOST + '/api/post/', files=files, data=data, headers=headers)
print(res)
print(res.json())

# Post#16 Detail
res = requests.get(HOST + '/api/post/', headers=headers)
res = requests.get(HOST + '/api/post/16/', headers=headers)
res.raise_for_status()
print(res.json())

# Post#16 Patch
res = requests.patch(HOST + '/api/post/16/', headers=headers, data={'message': 'hello'})
res.raise_for_status()
print(res.json())

# Post#16 Update
res = requests.put(HOST + '/api/post/16/', headers=headers, data={'message': 'hello'})
res.raise_for_status()
print(res.json())

# Post#16 Delete
res = requests.delete(HOST + '/api/post/16/', headers=headers, data={'message': 'hello'})
res.raise_for_status()
print(res.ok)

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 워크 스페이스 회고

개발자Dongbaek — Fri, 15 Jul 2022 00:57:31 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 14일 회고

너무 더워요

Chapter 1~4 회고록

https://devdongbaek.tistory.com/132

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 1~4 회고

devdongbaek.tistory.com

Chapter 5 회고록

https://devdongbaek.tistory.com/136

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 5 회고

devdongbaek.tistory.com

Chapter 6 회고록

https://devdongbaek.tistory.com/137

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 6 회고

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 13일 회고 부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습..

devdongbaek.tistory.com

이번주에는 워크 스페이스와 공동 월드 만드는 방법을 배웠다.

오늘 배운 학습량이 좀 적어서 아마 분량을 짧을 것 같다.

여러분들과 이야기 할 수 있는 순간이 적어져 굉장히 아쉽고, 슬프다.

여러분들께 MOD의 즐거움을 알려주는게 하루의 낙인데...

...

아쉬워라

워크 스페이스는 폴더 형식의 리소스 관리 공간을 의미한다.

워크 스페이스의 구조에 대해서 설명하자면 아래와 같다.

BaseEnvironment : MOD 메이커에서 제공하는 기본 MODComponent, MODService, MODLogic, MODEvent가 저장되어 있다.
MyDesk : 크리에이터가 추가한 리소스, BaseEncironment에서 확장, 복제한 모델, 컴포넌트 등이 추가된다. 새롭게 추가한 리소스는 MyDesk 폴더 하위에 저장된다. 필요할 때 폴더를 추가하여 효율적으로 리소스를 관리할 수 있다.
DefaultPlayer : NativeModel에 있는 Player의 정보를 참조하고 있다. 실제 생성한 플레이어 아바타 엔티티는 World 안에 속한다. 시작 시 스타트 포인트에 플레이어 아바타를 생성한다.

그 다음은 MOD 해커톤의 핵심 공동 제작하기이다.

MOD에서는 실시간으로 여러명이 협업해서 하나의 콘텐츠를 만들 수 있다.

공동 제작하기에 앞서서 먼저 그룹을 만들어야한다.

1. 먼저 그룹을 만들기 위해서는 MOD 포털 웹에 접속해야 한다.

https://mod.nexon.com/profile/SlLtD/home

https://signin.nexon.com/signin?redirect_uri=https://mod.nexon.com/profile/SlLtD/home

signin.nexon.com

2. 홈페이지에 들어갔다면 좌측 상단에 있는 만들기 탭에 들어가자. 그럼 아래와 같은 화면을 볼 수 있을 거다.

3. 만들기 탭 바로 밑에는 개인 월드와 그룹 월드가 있다. 그룹 월드 옆의 그룹만들기 버튼을 클릭하자.

4. 그룹 만들기 버튼을 클릭하시면 그룹 이름을 정하고, 동의하면 바로 그룹이 생성된다.

그룹장과 그룹멤버는 주어진 권한이 다르다.

정확한 정보는 아래 사진을 참고하자.

그렇다 한다.

멤버 초대는 MOD 프로필 이름을 검색해서 할 수 있다.

초대할 친구가 없다고..?

ㅠㅠ

나도...

라고 할줄 알았다면 미안하다.. 눈치 빠른 사람들은 알 수 있듯 위 사진에서 나는 팀원분들이 있다.

ㅎㅎ

그니까... 뭐라 해야할까...

다르다 당신과 나는

그러니까 만약 친구가 없다면 잠깐만 거리 둬주길 바란다.

저기 왕따인가봐..(수근 수근)

이렇게 그룹을 만들게 되면 공동 월드를 만들고, 함께 협업하여 월드를 제작할 수 있다.

우리 그룹이 만든 공동월드를 여러분들께 최초로 공개하며 오늘 글을 마치도록 하겠다

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

DRF Pagination

개발자Dongbaek — Thu, 14 Jul 2022 18:32:57 +0900

DRF에서 기본 지원하는 페이징 방식

PageNumberPagination

page/page_size 인자를 통한 페이징 처리

LimitOffsetPagination

offset/limit 인자를 통한 페이징 처리

PageNumberPagination

page_size 미지정 상황을 위해, 디폴트 지정이 필요

settings.py 내 REST_FRAMEWORK = {"PAGE_SIZE": 10} 를 통해 전역 설정
PageNumberPagination을 상속받아 page_size 설정

from rest_framework.pagination	import PageNumberPagination

class MyPageNumberPagination(PageNumberPagination):
    page_size = 10
    
# 특정 APIView에서 PageSize를 커스텀하고 싶다면 별도의 PageNumberPagination 클래스를 상속 받은 후 커스텀 지정 가능
class APIViewWithPage(APIView):
    pagination_class = PageNumberPagination

전역 설정

REST_FRAMEWORK	=	{
     'PAGE_SIZE': 10,
     'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
}

DRF Authentication과 Permission

개발자Dongbaek — Thu, 14 Jul 2022 17:52:15 +0900

인증

유입되는 요청을 허용 / 거부하는 것을 결정하는 것이 아니라, 단순히 인증 정보로 유저를 식별하는 것입니다.

Authentication : 유저 식별(ex: 업주인지 고객 유저인지)
Permissions : 유저의 리소스에 대한 각 요청에 대한 허용/거부(ex: 특정 유저만 글 쓰기)
Throttling : 특정 유저가 일정 시간 동안에 허용할 최대 요청 횟수(ex: 글 쓰기 제한)

인증 프로세스

유저 식별
해당 유저가 리소스에 대한 어떤 액션을 취할 때 허용할 것인지, 거부할 것인지
허용된다면, 특정 리소스에 대한 요청 횟수를 넘어서지 않는지

인증 처리 순서

매 요청 시마다 APIView의 dispatch(request) 호출
APIView의 initial(request) 호출
APIView의 perform_authentication(request) 호출
- 세션 인증은 로그인을 할 때만 인증을 하고, 인증을 한 내역을 세션에 담아두고 활용하는데, API에서는 매번 클라이언트가 서버에 요청을 보낼 때 마다 매번 인증을 한다. 즉 매번 인증을 해서 이 요청이 유효한지 검사한다.
- 인증 방법은, 매 인증 시 json 토큰을 보내거나, 매번 username/password를 올리는 등 여러가지 방법이 있다.
request의 user속성 호출 (rest_framework.request.Request 타입)
request의 _authenticate() 호출 - 실제 인증 로직

지원하는 인증 (Authentication)의 종류

SessionAuthentication

세션을 통한 인증, APIView에서 디폴트 지정
한번만 로그인 하면 그 정보를 세션에 담아두고, 저장된 세션을 통해 인증하는 것

BasicAuthentication

클라이언트가 서버에게 매 요청시마다 요청 헤더에 인증 정보를 보내는 것
Base 인증 헤더를 통한 인증 (예 → Authorization: Basic YWxsaWV1czE6MTAyOXNoYWtl )
- HTTPie를 통한 요청 : 쉘> http --auth 유저명:암호 --form POST :8000 필드명1:값1 필드명2:값2
암호는 base64 인코딩되어 지정
http요청일 경우 누구나 스니핑 해서 볼 수 있음. -> 그래서 반드시 https를 사용해야 한다.

TokenAuthentication

Basic과 똑같이 요청헤더에 인증 정보를 보내는데 대신, 비밀번호가 아닌 유저마다 Unique한 랜덤한 문자열을 통해 인증한다.
Token 헤더를 통한 인증 (예 → Authorization: Token 401f7ac837da42b97f613d789819ff93537bee6a)
장점은 구현이 쉽다는 점, 단점은 Token의 만료 기한이 정해지지않은 것과, 유저별 하나의 Token만 제공되는 것(유출될 시 큰일)
마찬가지로 http요청일 경우 누구나 스니핑 해서 볼 수 있음.
DRF에서 지원하는 Token은 예시로만 보면 되고, 실 구현시에는 JWT과 세션 인증으로 구현

RemoteUserAuthentication

User가 다른 서비스에서 관리될 때, Remote 인증
Remote-User 헤더를 통한 인증 수행

ModelView 및 APIVIew에서 인증과 허가를 구현하기 위해서는 아래 예시 코드와 같이 작성하면 됩니다.

# Blog의 목록, detail 보여주기, 수정하기, 삭제하기 모두 가능
class BlogViewSet(viewsets.ModelViewSet):
    # authentication 추가
    authentication_classes = [BasicAuthentication, SessionAuthentication]
    
    # permission 추가
    permission_classes = [IsAuthenticatedOrReadOnly]
    queryset = Blog.objects.all()
    serializer_class = BlogSerializer

웹브라우저를 통한 API 접근에서 로그인/로그아웃 지원

장고 기본 앱 django.contrib.auth를 통한 지원 → 세션 인증

rest_framework/urls.py

from django.conf.urls import url
from django.contrib.auth import views

app_name = 'rest_framework'
urlpatterns = [
    url(r'^login/$', views.LoginView.as_view(template_name='rest_framework/login.html'),
         name='login'),
    url(r'^logout/$', views.LogoutView.as_view(), name='logout'),
]

프로젝트 내 urls.py

urlpatterns += [
    path('api-auth/', include('rest_framework.urls', namespace='rest_framework')),
]

허가와 권한

인증과 허가

개체(정보/코드 등)에 대한 접근을 허용하기 위해서, 인증/식별만으로는 충분하지 않습니다. 추가로 각 개체에 대한 허가가 필요합니다.

DRF의 Permission 시스템

현재 요청에 대한 허용/거부를 결정합니다. APIView 단위로 지정할 수 있습니다.

AllowAny (디폴트 전역 설정) : 인증 여부에 상관없이, 뷰 호출 허용 -> 적합하지 않다.
IsAuthenticated : 인증된 요청에 한해서, 뷰 호출 허용 -> 비로그인자는 조회도 안되게 할 때 전역 디폴트 권고
- 해당 ViewSet에 접근을 위해서는 무조건 로그인 되어있어야 합니다.
IsAdminUser : Staff 인증 요청에 한해서, 뷰 호출 허용
- is_staff은 admin 페이지에 접근할 수 있는 권한이다. 단 장고 기본 모델에 있는 적절한 Permission이 주어져야 함
IsAuthenticatedOrReadOnly : 비인증 요청에게는 읽기 권한만 허용 → 최소 전역 디폴트 설정 권고
DjangoModelPermissions : 인증된 요청에 한해 뷰 호출을 허용하고, 추가로 장고의 모델단위 Permissions 체크
- 장고 Auth의 Permission과 DRF의 Permission은 다르다.
- 해당 Permission은 Django Auth Permission이다.
DjangoModelPermissionsOrAnonReadOnly : DjangoModelPermissions과 유사하나, 비인증 요청에게는 읽기만 허용
DjangoObjectPermissions : 비인증 요청은 거부하고, 인증된 요청은 Object에 대한 권한 체크를 수행

permission_classes 지정

CBV 즉, APIView에는 permission_classes 설정

from rest_framework.permissions import IsAuthenticated

class ExampleView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request, format=None):
        content = { 'status': 'request was permitted' }
        return Response(content)

FBV 즉, @api_view에는 @permission_classes 장식자 설정

from rest_framework.decorators import permission_classes

@api_view(['GET'])
@permission_classes([IsAuthenticated])
def example_view(request, format=None):
    content = { 'status': 'request was permitted' }
    return Response(content)

디폴트 전역 설정

# settings.py

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
    ]
}

커스텀 Permission

모든 Permission 클래스는 다음 2가지 함수를 선택적으로 구현되어있고, 커스텀 Permission 시 구현해야한다.

has_permission(request, view)
- APIView 접근 시, 체크
- 거의 모든 Permission 클래스에서 구현하며, 로직에 따라 True/False 반환
- 항상 APIView 클래스를 상속받아서 DRF를 사용해야 함

has_object_permission(request, view, obj)
- APIView의 get_object 함수를 통해 object 획득 시에 체크
- 브라우저를 통한 API 접근에서 CREATE/UPDATE Form 노출 시에 체크
- DjangoObjectPermissions에서 구현하며, 로직에 따라 True/False 반환
- 특정 Object를 획득할 때는 반드시 해당 APIView에서 self.get_object를 이용하여 object를 얻어야 한다.

룰 기반 퍼미션 지원 : https://github.com/dbkaplan/dry-rest-permissions

GitHub - dbkaplan/dry-rest-permissions: Rules based permissions for the Django Rest Framework

Rules based permissions for the Django Rest Framework - GitHub - dbkaplan/dry-rest-permissions: Rules based permissions for the Django Rest Framework

github.com

DRF의 Permissions 코드 살펴보기

# https://github.com/encode/django-rest-framework/blob/3.10.1/rest_framework/permissions.py
SAFE_METHODS = ('GET', 'HEAD', 'OPTIONS')

class AllowAny(BasePermission):
    def has_permission(self, request, view):
        return True  # 무조건 허용

class IsAuthenticated(BasePermission):
    def has_permission(self, request, view):
        return request.user and request.user.is_authenticated  # 유저가 있고, 로그인 된 유저만 허용

class IsAdminUser(BasePermission):
    def has_permission(self, request, view):
        return request.user and request.user.is_staff  # 스태프 여부 판단

# https://github.com/encode/django-rest-framework/blob/3.10.1/rest_framework/permissions.py

class DjangoObjectPermissions(DjangoModelPermissions):  # 장고 기본의 퍼미션을 체크한다.
    # ...
    def has_object_permission(self, request, view, obj):
        # authentication checks have already executed via has_permission
        queryset = self._queryset(view)
        model_cls = queryset.model
        user = request.user

        perms = self.get_required_object_permissions(request.method, model_cls)

        if not user.has_perms(perms, obj):
            if request.method in SAFE_METHODS:
                raise Http404

            read_perms = self.get_required_object_permissions('GET', model_cls)
            if not user.has_perms(read_perms, obj):
                raise Http404
            return False

        return True

장고 기본 Permission은 Django Admin Page에서 유저의 Permission에서 확인할 수 있다.

커스텀 퍼미션 예시 : 포스팅 작성자가 아니라면, 읽기 권한만 부여하기.

모델에 author 필드가 있다고 가정

from rest_framework import permissions

class IsAuthorOrReadonly(permissions.BasePermission):
    # 인증된 유저에 한해, 목록조회/포스팅등록을 허용
    def has_permission(self, request, view):
        return request.user.is_authenticated  # 인증이 되야만 허용

    # 작성자에 한해, Record에 대한 수정/삭제 허용
    def has_object_permission(self, request, view, obj):
        # 조회 요청(GET, HEAD, OPTIONS) 에 대해서는 인증여부에 상관없이 허용
        if request.method in permissions.SAFE_METHODS:  # SAFE_METHODS = ('GET', HEAD', 'OPTIONS')
            return True

        # PUT, DELETE 요청에 대해, 작성자일 경우에만 요청 허용
        return obj.author == request.user

Head method -> 응답 헤더만 받는 것
Options method -> 엔드포인트에서 어떠한 메소드를 지원하는지 알려주는 것

포스팅 작성자에게 수정권한만 부여하고, 삭제는 superuser에게만 가능케 하는 Permission 클래스 정의

from rest_framework import permissions

class IsAuthorUpdateOrReadonly(permissions.BasePermission):
    def has_permission(self, request, view):
        return request.user.is_authenticated

    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True

        if (request.method == 'DELETE'):
            return request.user.is_superuser  # 또는 request.user.is_staff

        return obj.author == request.user

권한 확인하기

Django Shell에서 간단한 비밀번호를 가진 유저 생성하기

# python shell
>>> from django.contrib.auth import get_user_model
>>> User = get_user_model()
>>> User.objects.create_user?
Signature:
User.objects.create_user(
    username,
    email=None,
    password=None,
    **extra_fields,
)
Docstring: <no docstring>
...
>>> User.objects.create_user('user2', password='1234')
<User: user2>

인증된 유저로 요청하기

http --auth user2:1234 http://localhost:8000/post/1/   # 
http --auth user2:1234 POST http://localhost:8000/post/ message="user2가 지정하는 첫 메시지"
http --auth user2:1234 PATCH http://localhost:8000/post/6 message="user2가 수정하는 첫 메시지"
http --auth user2:1234 PATCH http://localhost:8000/post/1 message="수정?"  # author가 다르면, 거부됨
http --auth user2:1234 gethttp://localhost:8000/post/1  # author가 달라도 조회는 가능!

ex) 고객 유저 Permission

from rest_framework import permissions

class IsCustomer(permissions.BasePermission):
    # 고객 유저에 한해, 목록조회/포스팅등록을 허용
    def has_permission(self, request, view):
        return request.user.IsCustomer  # Customer 필드가 True 이어야만 허용

    # 고객 유저에 한해, Record에 대한 수정/삭제 허용
    def has_object_permission(self, request, view, obj):
        # 조회 요청(GET, HEAD, OPTIONS) 에 대해서는 인증여부에 상관없이 허용
        if request.method in permissions.SAFE_METHODS:  # SAFE_METHODS = ('GET', HEAD', 'OPTIONS')
            return True

        # PUT, DELETE 요청에 대해, 작성자일 경우에만 요청 허용
        return obj.author == request.user

DRF Serializer를 통한 유효성 검사 및 저장

개발자Dongbaek — Thu, 14 Jul 2022 16:05:33 +0900

Serializer의 생성자

Serializer는 Django Form과 컨셉 / 사용법이 유사하나, 생성자 차이

# django/forms/forms.py
class BaseModelForm:
    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, 
                initial=None, error_class=ErrorList, label_suffix=None, 
                empty_permitted=False, instance=None, use_required_attribute=None):

class Form(BaseForm):
    pass

Form에서는 인자로 data와 files, instance를 받는다.

# rest_framework/serializers.py
class BaseSerializer(Field):
    def __init__(self, instance=None, data=empty, **kwargs):

# instance -> 직렬화 목적
# data -> 유효성 검사

class Serializer(BaseSerializer):
    pass

Serializer에서는 인자로 instance와 data를 받는다.

data = 인자가 주어지면

.is_valid()가 호출되고 나서야

.initial_data 필드에 접근할 수 있고
.validated_data (form에서는 cleaned_data)를 통해 유효성 검증에 통과한 값들이 .save()시에 사용됩니다.
- form은 cleaned_data라는 똑같은 기능 존재
.errors → 유효성 검증 수행 후에 오류 내역
.data → 유효성 검증 후에, 갱신된 인스턴스에 대한 필드값 사전
- 즉 유효성 검사를 마쳐야 위의 기능들을 활용할 수 있다.

우리가 Serializer를 활용하는 패턴 2가지

데이터 직렬화를 사용하기 위해서
- 직렬화가 목적인 경우 instance 인자에 model 객체 혹은 쿼리셋을 넘겨준다.
Form과 유사하게 입력값에 대한 유효성 검사와 유효성 검사 통과 값들을 사전 형태로 가져오고, DB로 저장하게 하는 것
- 유효성 검사를 위해서는 instance와 data에 인자를 넘겨주어야 한다.

serializer.save(**kwargs) 호출을 할 때

DB에 저장한 관련 instance를 리턴
.validated_data와 kwargs사전을 합친 데이터를
- .update 함수 / .create함수를 통해 관련 필드에 값을 할당하고, DB로의 저장을 시도
- 그러면 언제 update와 create를 지원하는지
  - .update() : self.instance 인자를 지정했을 때
  - .create() : self.instance 인자를 지정하지 않았을 때

# Form에서의 데이터 save코드
form = PostForm(request.POST)
if form.is_valid():
    post = form.save(commit=False)
    post.author = request.user
    post.ip = request.META['REMOTE_ADDR']
    post.save()

# Serializer에서의 데이터 save코드
serializer.is_valid(...) # ex)raiseException
# serializer.save에 내가 업데이트 하고 싶은 인자들을 넘겨주면 된다.
serializer.save(author=request.user, ip=request.META['REMOTE_ADDR'])

from rest_framework.validators import ...

https://github.com/encode/django-rest-framework/blob/master/rest_framework/validators.py

GitHub - encode/django-rest-framework: Web APIs for Django.

Web APIs for Django. . Contribute to encode/django-rest-framework development by creating an account on GitHub.

github.com

값에 대한 유효성 검사를 수행하는 호출 가능한 객체
DRF에서는 유일성 체크를 도와주는 Validators 제공

UniqueValidator : 지정 1개 필드가 지정 QuerySet범위에서의 유일성 여부 체크
UniqueTogetherValidator : UniqueValidator의 다수 필드 버전
BaseUniqueForValidator
UniqueForDateValidator (BaseUniqueValidator) : 지정 날짜 범위에서 유일성 여부 체크
UniqueForMonthValidator (BaseUniqueValidator) : 지정 월 범위에서의 유일성 여부 체크
UniqueForYearValidator (BaseUniqueValidator) : 지정 년 범위에서 유일성 여부 체크

UniqueValidator

모델 필드에 unique=True를 지정하면 자동 지정

queryset(필수) : 대상 쿼리셋의 범위를 지정해줌
message : 유효성 검사 실패 시의 에러 메세지
lookup : 디폴트 'exact'
- Serializer 필드에 직접 Validators 지정 가능
- 그러나 웬만하면 모델 필드에서 unique=True를 지정함으로써 모델 Serilizer에서 Validator가 자동으로 추가되도록 하는것을 추천

from rest_framework.validators import UniqueValidator

slug = SlugField(
    max_length=100,
    validators=[UniqueValidator(queryset=BlogPost.objects.all())]
)

UniqueForDateValidator / Month / Year

특정 쿼리 셋에서 → 특정 날짜 범위 내에서 → 특정 필드가 유니크한지 검사

queryset (필수) : 대상 쿼리셋의 범위
field (필수)
date_field (필수) : Date, Month, Year값이 참조 할 날짜 필드 (필드 상에서 연/월/일 중 Validator에 맞게 참조한다.)
- 특정 날짜의 범위 안에 있는 / 특정 쿼리셋의 범위 내에서 / 특정 필드가 Unique한지에 대해서
message

from rest_framework.validators import UniqueTogetherValidator
class ExampleSerializer(serializers.Serializer):
    # ...
    class Meta:
        validators = [
            UniqueForYearValidator( 
                queryset=BlogPostItem.objects.all(), 
                field='slug', 
                date_field='published'
            ) 
        ]

유효성 검사에 실패하면 ValidationError 예외 발생

필히 rest_framework.exception.ValidationError 사용
장고 기본에서는 django.forms.exceptions.ValidationError

class ValidationError(APIException):
    status_code = status.HTTP_400_BAD_REQUEST
    default_detail = _('Invalid input.')
    default_code = 'invalid'

    def __init__(self, detail=None, code=None):
        if detail is None:
            detail = self.default_detail
        if code is None:
            code = self.default_code

        if not isinstance(detail, dict) and not isinstance(detail, list):
            detail = [detail]

        self.detail = _get_error_details(detail, code)

Serializer에서의 유효성 검사

Serializer의 유효성 검사하는 2가지 방법

필드 정의시에 validators 지정하기
클래스 Meta.validators 지정
ModelSerializer 같은 경우에는 model 단에 유효성 검사 로직 구현하기

Field Level 검사: 유효성 검사 및 값 변환

class PostSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=100)

    def validate_title(self, value): # validator_필드명을 구현해서 유효성 검사를 진행할 수 있다. (form에서는 clean_필드명)
        if 'django' not in value:
            raise ValidationError('제목에 필히 django가 포함되어야합니다.')  # 조건에 맞지않으면 rest_framework의 validationError를 발생시킨다. (form에 있는 validationError랑 헷갈리면 안됨)
        return value

Object Level 검사: 유효성 검사 및 값 변환

class PostSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=100)

    def validate(self, data):  # 2개 이상의 필드에 대해 유효성 검사 로직은 validate를 구현하면 된다.(form에서는 clean)
        if 'django' not in data['title']:
            raise ValidationError('제목에 필히 django가 포함되어야합니다.')
        return data

DB로의 반영과 Mixins의 perform_ 계열 함수

APIView의 create/update/destroy 멤버함수에서 실질적인 DB처리 로직은

perform_create(serializer)
perform_update(serializer)
perform_destroy(instance)
를 통해 이루어진다.

class CreateModelMixin:
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()  # 모델 객체가 만들어지고, 모델 객체의 값들이 할당이 다 된 model.save()가 호출이 되는 것이다.

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

create 시에 추가로 저장할 필드가 있다면?

모델에 ip 필드가 있고, 유저의 아이피들 저장하고 싶다면?

# CreateModelMixin에서 상속받은 뷰에서 아래와 같이 사용한다.

def perform_create(self, serializer):  # 실제 APIView구현에서 
   author = self.request.user
   ip = self.request.Meta['REMOTE_ADDR']
   serializer.save(author=author, ip=ip)

User가 data를 수정이나 읽지 못하게 하는 방법

Serializer에서 ReadOnly를 걸거나
model 필드 옵션으로 editable=False로 설정

From과 Serializer 관점에서 DRF 비교

개발자Dongbaek — Wed, 13 Jul 2022 15:32:28 +0900

Serializer / ModelSeializer

데이터 변환 / 직렬화 지원

querySet / Model객체 <-> Native Python 데이터타입, JSON/XML

Django의 Form / ModelForm과 유사

유효성 검사와 유효성 검사에 통과한 값들을 데이터베이스에 저장 시켜줌
Serializer는 뷰 응답을 생성하는 데에 범용적이고 강력한 방법을 제공
ModelSerializer는 Serializer 생성을 위한 Shortcut

특징 비교

Form / ModelForm

HTML 입력폼을 위한 입력에 대한 유효성 검사
주로 Create / Update에 대한 처리에서 활용 → 장고 admin에서 활용
CreateView / UpdateView CBV를 통한 뷰 처리 → 단일 뷰

Serializer / ModelSerializer

데이터 변환 및 직렬화 지원 (JSON포맷 등)
주로 JSON 포맷 (주된 Web API 포맷) 입력에 대한 유효성 검사
List / Create 및 특정 Record(Resource)에 대한 Retrieve / Edit(update or partial_update) / Delete 등에서 활용
APIView를 통한 뷰 처리 → 단일 뷰
ViewSet을 통한 뷰 처리 → 2개 뷰 → 2개 URL 처리

주된 호출 주체 비교

Form / ModelForm

일반적으로 웹 브라우저 상에서
- HTML Form Submit (POST 요청)
- JavaScript에 의한 비동기 호출
물론 Android/iOS앱에 의한 요청/응답도 가능
- 모두 http(s) 프로토콜 요청 / 응답이기에

Serializer / ModelSerializer

다양한 Client에 대한 Data위주의 http(s)요청
- by: Web / Android / iOS 등

클래스 정의 비교

Form / ModelForm : Form은 html 폼을 효율적으로 처리하기 위한 목적을 가진다.

from django import forms

class PostForm(forms.Form):
    email = forms.EmailField()
    content = forms.CharField(**widget=forms.Textarea**)
    created_at = forms.DateTimeField()

class PostModelForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = '__all__'

Serializer / ModelSerializer : Serializer는 다양한 http 클라이언트로부터의 API 요청을 처리하기 위한 목적을 갖기에, widget과 같은 인자는 없다.

from rest_framework import serializers

# 시리얼라이저/디시리얼라이저 되어야 하는 필드 정의 필요
# create(), update() 메소드 정의 필요
# create(): 시리얼라이저를 대상으로 save() 메소드를 호출하여 DB 인스턴스를 생성할 때의 동작 정의
# update(): 시리얼라이저를 대상으로 save() 메소드를 호출하여 DB 인스턴스를 수정하고자 할 때의 동작 정의

class PostSerializer(serializers.Serializer):
    email = serializers.EmailField()
    content = serializers.CharField(max_length=200)
    created_at = serializers.DateTimeField()

# Model과 필드를 정의
class PostModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

FBV를 통한 요청 / 응답 비교 – Form vs Serializer

Form

def post_create(request):
    if request.method == 'POST':
        form = PostForm(request.POST, request.FILES)
        if form.is_valid():
            post = form.save()
            return redirect(post)
    else:
        form = PostForm()
    return render(request, 'myapp/post_form.html', { 
        'form': form,
    })

def post_list_or_create(request):
    # 새 글 저장을 구현
    if request.method == 'POST':
        form = PostForm(request.POST, request.FILES)
        if form.is_valid():
            post = form.save()
            # 커스텀 직렬화 루틴이 필요
            return JsonResponse(post)
        return JsonResponse(form.errors)
    # 목록 응답을 구현
    else:
        qs = Post.objects.all()
        return JsonResponse(qs) # 커스텀 직렬화 루틴이 필요

Serializer

def post_list_or_create(request):
    if request.method == 'POST':
        serializer = PostSerializer(data=request.POST)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)
    else:
        qs = Post.objects.all()
        serializer = PostSerializer(qs, many=True)
        return Response(serializer.data)

from rest_framework.response import Response
from rest_framework.views import APIView

class PostListCreateAPIView(APIView):
    def get(self, request):
        serializer = PostSerializer(Post.objects.all(), many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = PostSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

CBV를 통한 요청 / 응답 비교 – Form vs Serializer

장고 기본

from django.views.generic import ListView, CreateView

post_list = ListView.as_view(model=Post)

post_new = CreateView.as_view(model=Post, form_class=PostModelForm)

# 앱/urls.py
urlpatterns = [
    path('', post_list),
    path('new/', post_new),
]

<form action="" method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <table>
        {{ form.as_table }}
    </table>
    <input type="submit" />
</form>

DRF의 APIView

from rest_framework.generics import ListCreateAPIView
class PostListCreateAPIView(ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostModelSerializer

post_list_create = PostListCreateAPIView.as_view()

# 앱/urls.py
urlpatterns = [
# 단일 URL에서 list/create 요청 처리
    path('api/post/', post_list_create),
]

유효성 검사 수행 시점 – Form vs Serializer

Form

class ProcessFormView(View):
    def get(self, request, *args, **kwargs):
        return self.render_to_response(self.get_context_data())

    def post(self, request, *args, **kwargs):
        form = self.get_form() # POST 데이터를 통해 Form 객체 생성
        if form.is_valid(): # 유효성 검사를 수행. 실패하면 False를 반환
            return self.form_valid(form) # DB로의 저장을 수행
        else:
            return self.form_invalid(form) # 오류 HTML 응답

Serializer

# rest_framework/mixins.py
class CreateModelMixin(object):
    def create(self, request, *args, **kwargs): # POST 요청 -> CREATE 요청이 들어오면,
        serializer = self.get_serializer(data=request.data) # POST데이터를 통해 Serializer 인스턴스를 만들고
        serializer.is_valid(raise_exception=True) # 유효성 검사를 수행. 실패하면 예외발생 !!!
        self.perform_create(serializer) # DB로의 저장을 수행
        headers = self.get_success_headers(serializer.data) # 필요한 헤더를 뽑고
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers) # 응답을 합니다.

def perform_create(self, serializer): # CREATE 커스텀은 이 함수를 재정의하세요.
serializer.save()

커스텀 유효성 검사 루틴 - clean_* vs validate_*

Form -> clean_

from django import forms
class PostForm(forms.Form):
    title = forms.CharField()

    def clean_title(self):
        value = self.cleaned_data.get('title', '')
        if 'django' not in value:
            raise forms.ValidationError('제목에 필히 django가 포함되어야 합니다.')
        return value

Serializer -> validate_

from rest_framework.exceptions import ValidationError

class PostSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=100)

    def validate_title(self, value):
        if 'django' not in value:
            raise ValidationError('제목에 필히 django가 포함되어야 합니다.')
        return value

DRF ViewSet과 Router

개발자Dongbaek — Wed, 13 Jul 2022 14:24:01 +0900

REST의 규칙에 우리는 맞춰 코딩을 하고있음을 인지하는게 매우 중요하다.

ViewSet은 REST의 반복적인 코딩 패턴을 줄여준다.

우리는 일반적으로 REST API를 구현할 때 모델을 기준으로 List와 Detail URL에 대한 API를 구현한다.

이 때 List API는 GET, POST 메소드를 구현하며 Detail API 는 GET, PUT, DELETE메소드를 구현한다.

이 각 2개의 URL별로 모두 5개의 메소드 구현을 REST의 반복되는 일관된 패턴으로 볼 수도 있을 것이다.

DRF에서는 모델을 기준으로 하나의 ViewSet으로 묶어서 위에서 언급한 패턴을 한방에 구현할 수 있다. ViewSet에 queryset과 serializer를 지정만 해주고 Router클래스로 url에 추가만 해주면 된다.

ViewSet

단일 리소스에서 관련있는 View들을 단일 클래스에서 제공

위의 말을 쉽게 설명 하자면 RESST API는 일반적으로 2개의 URL이 필요하다.
- list/create, detail/update/partial_update/delete로 나눠지는 2개의 클래스 기반 뷰가 필요하다.
그러나 ViewSet에서는 2개의 구현을 단일 클래스에서 지원해준다.

# https://www.django-rest-framework.org/tutorial/6-viewsets-and-routers/
from rest_framework import viewsets
from rest_framework.response import Response

class PostViewSet(viewsets.ViewSet):
    def list(self, request):  # list
        queryset = Post.objects.all()
        serializer = PostSerializer(queryset, many=True)
        return Response(serializer.data)

    def retrieve(self, request, pk):  # detail
        queryset = Post.objects.all()
        user = get_object_or_404(queryset, pk=pk)
        serializer = PostSerializer(user)
        return Response(serializer.data)

# https://www.django-rest-framework.org/api-guide/routers/
router = DefaultRouter()
router.register('post', PostViewSet, basename='post')  # 2개의 URL을 만들어준다.
router.urls

# urls에 다음과 같이 추가한다. -> path('', include(router.urls)

위는 메소드들을 직접 구현한 것이고, ModelViewSet을 상속받으면 메소드가 전부 구현이 되어있다.

# https://www.django-rest-framework.org/tutorial/6-viewsets-and-routers/
from rest_framework import ModelViewSet
from rest_framework.response import Response

class PostViewSet(ModelViewSet):
	queryset = Post.objects.all()
    serializer_class = PostSerializer

ModelViewSet에서는 쿼리셋과 Serializer만 적으면 된다. // 기본 메소드가 모두 구현되어있기에

ModelViewSet

2가지 ModelViewSet이 존재한다.

Viewsets.ReadOnlyModelViewSet -> GET 요청(조회)에만 반응하는 ModelViewSet

list 지원 → 1개의 URL
detail 지원 → 1개의 URL

Viewsets.ModelViewSet -> GET뿐만 아니라 모든 요청에 반응하는 ModelViewSet

list/create 지원 → 1개의 URL
detail/update/partial_update/delete 지원 → 1개의 URL

URL Patterns에 매핑

from rest_framework import viewsets

class PostViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

필요한 method만 뽑아서 개별 View를 만들수도있고

# PostViewSet으로부터 필요한것만 뽑아 쓰기

#'입력받은 mehtod' : '출력할 함수' 

post_list = PostViewSet.as_view({
    'get': 'list',
})
post_detail = PostViewSet.as_view({
    'get': 'retrieve',
})

# urls에 하나하나 직접 path를 다 써야한다.

또 다른 예시

message_list = MessageViewSet.as_view({
        'get': 'list',
        'post': 'create',
    })

message_detail = MessageViewSet.as_view({
    'get': 'retrieve',
    'put': 'update',
    'patch': 'partial_update',
    'delete': 'destroy'
})

urlpatterns = [
    path('/message', message_list),
    path('/message/<int:pk>', message_detail),
]

Router 통해서 일괄적으로 urlpatterns에 등록할 수 있다.

# Router를 통해 일괄등록을 하면 추가 기능이 있다. 
# http://localhost:8000/post/1.api, http://localhost:8000/post/1.json 등의 포맷 인자(api, json)를 추가로 url_patterns에 추가된다. 포맷 인자로 요청 시 요청에 따라 json, api응답이 온다. 아래 Router 참조

from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register('post', views.PostViewSet)  # 'post': URL에 사용될 리소스 이름이다. 보통은 모델명 사용

urlpatterns = [
    path('', include(router.urls)),
]

http://localhost:8000/post/1.api, http://localhost:8000/post/1.json 등의 포맷 인자(api, json)를 추가로 url_patterns에 추가된다. 포맷 인자로 요청 시 요청에 따라 json, api(DRF html)응답이 온다.

Router

ReadOnlyModelViewSet과 ModelViewSet에 대해서 동일한 URL Pattern 리스트가 생성된다.

list route
detaul route

from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register('post', views.PostViewSet) # 'post'가 url의 prefix가 된다.

urlpatterns = [
    path('', include(router.urls)),
]



# 아래 URL 패턴들은 위 router 추가시 자동으로 등록되는 주소들이다.
[
    <URLPattern '^post/$' [name='post-list']>, 
    <URLPattern '^post\.(?P<format>[a-z0-9]+)/?$' [name='post-list']>, # 주의) 구분자 "_"가 아니라 "-"이다.
    <URLPattern '^post/(?P<pk>[^/.]+)/$' [name='post-detail']>,
    <URLPattern '^post/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)/?$' [name='post-detail']>,
    <URLPattern '^$' [name='api-root']>,
    <URLPattern '^\.(?P<format>[a-z0-9]+)/?$' [name='api-root']>  
# api-root : 현 Router에 등록된 ViewSet내역을 조회
]

ViewSet에 새로운 EndPoint 추가하기

EndPoint란

특정 URL을 호출하게 되면, 생성되고
하나의 endpoint 는 보통 JSON 포맷으로 된 데이터와 동작 가능한 HTTP method 정보를 가지고 있다.

from rest_framework.decorators import action

class PostModelViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

		"""
    URL Reverse 명: basename-함수명 (언더바는 하이픈으로 변경)
										즉, post-public이 된다.
		"""
    @action(detail=False, methods=['GET'])  # 특정 포스팅이 아니므로 detail=False
    def public(self, request):
        qs = self.get_queryset().filter(is_public=True)
        serializer = self.get_serializer(qs, many=True)
        return Response(serializer.data)

    @action(detail=True, methods=['PATCH']) # 특정 포스팅이므로 detail=True
    def set_public(self, request, pk):  # public으로 변경하는 api
        instance = self.get_object()
        instance.is_public = True
        instance.save()  # 또는 instance.save(update_fields=['is_public'])
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

    # @action의 detail인자에 따라서 list URL을 탈건지, detail URL을 탈건지 결정된다.

get_serializer(쿼리셋, many=True)에서 many=True는 여러 객체를 가져온다는 것을 의미한다.

Router 사용시 API를 반환하는 함수 이름으로 자동으로 endpoints가 생성된다.

위 코드를 통해 자동으로 생성된 URL Patterns 리스트

[
    # ...
    <URLPattern	'^post/public/$' [name='post-public']>,
    <URLPattern	'^post/public\.(?P<format>[a-z0-9]+)/?$' [name='post-public']>,
    # ...
    <URLPattern	'^post/(?P<pk>[^/.]+)/set_public/$' [name='post-set-public']>,
    <URLPattern	'^post/(?P<pk>[^/.]+)/set_public\.(?P<format>[a-z0-9]+)/?$' [name='post-set-public']>,
    # ...
]

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 6 회고

개발자Dongbaek — Wed, 13 Jul 2022 12:22:08 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 13일 회고

오늘도 반갑습니다.

Chapter 1~4 회고록

https://devdongbaek.tistory.com/132

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 1주차 회고

부족하지만 멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon에 합격하게되어서 MOD를 먼저 사용해볼 수 있는 감사한 기회를 얻게 되었습니다...! 최선을 다해 공부하고, 리뷰하겠습니다! 부족한 글 보러

devdongbaek.tistory.com

Chapter 5 회고록

https://devdongbaek.tistory.com/136

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 5 회고

devdongbaek.tistory.com

이번 Chapter 6에서는 스크립트에 대해 배워보았다.

MOD는 Lua라는 언어에 MOD만의 문법이 추가된 형식이다.

// Lua는 파이썬과 같이 동적언어라고 한다.

Lua 스크립트의 기본적인 문법은 아래와 같다.

--출력
log("Hello World!")



--변수 선언
local number = 1 
local sum = 0


--반복문 선언
	for count = 1, 10, 1 do  --1부터 10까지 1씩 증가
	
    end


--조건문
	if count%2 == 0 then
		sum = sum + count
	end



--함수
void Sum()
{

}

분명 기본으로 제공되는 컴포넌트나 여러 기능이 있는데 왜 코드, 스크립트를 작성해야 할지에 대해 궁금할 수도 있을 것 같다.

흐음

그 이유는 마우스 클릭이나, 드래그등 기본적인 방법만으로는 표현에 한계가 있기에 이를 극복하기 위해서 코드, 스크립트를 작성하게 된다.

Chapter 5와 마찬가지로 주로 사용하는 스크립트에 대해서 알아보자

스크립트는 두 가지로 나눌 수 있다.

Create Component와 Create Logic

먼저 Create Component에 대해서 알아보자

Component의 특징은 아래와 같다.

Component는 여러 개 존재할 수 있다.
코드 작성 이후 해당 Component 탑재를 희망하는 Entity에 반드시 반드시 추가해주어야 한다.

코드 작성 후 Entity에 Component를 추가하지 않고, 왜 적용이 안되지라고 생각하는 경우가 생각보다 많다

부끄부끄

Create Component의 기본적인 창

위 컴포넌트의 구성요소에 대해서 이야기해보겠다.

먼저 Property를 설정할 수 있고, 설정한 Property는 Property 창(패널)에 노출되게 된다.

Function은 Component에서 사용될 함수이고, 내가 속한 property나 다른 함수를 가져다 쓸 때

self.컴포넌트명으로 컴포넌트를 불러와 사용할 수 있다.

Entity Event Handler는 해당 Component를 가진 Entity에게 이벤트가 발생했을 경우 실행할 함수이다.

예를 들어)
Entity가 바라보는 방향이 바뀌면 함수를 실행
Entity가 포탈을 이용하면 함수를 실행
Entity가 채팅을 입력하면 함수를 실행

자주 사용되는 함수는

OnBeginPlay : 컴포넌트가 초기화가 될 때(처음 시작할 때) 처리하는 로직
OnUpdate : 프레임마다 주기적으로 불리는 함수
OnEndPlay : 끝날 때 처리하는 로직

가 있다.

그러면 재밌는 예시(?)를 통해 오늘도 Create Component를 배워볼까???

레츠꼬

이제는 모두가 우리 중학생 형을 알거라고 가정하고, 예시를 만들겠다.

알거라고 가정하고

사랑합니다.

실제로 순찰하는 중학생 형과 마주치게 된다면 우리는 어떻게 되겠는가?

잔뜩 경락 마사지를 받고, 소득세를 지불하지 않겠는가?

눙물...

이를 게임상에서 구현하여 형과 충돌이 일어날 경우 HP를 닳게 하고, 넉백(뒤로 밀려남)을 구현해보자

1. 첫번째로 Create component를 통해 "Bbing"이라는 Component을 만들자.

2. 내 캐릭터에 이 컴포넌트를 적용하기위해 Default Player의 Propery 패널에서 Bbing Component를 Add 해주자.

3. 저번 회고에서 형에게 TweenLinComponent를 추가해줌으로써 반복적인 움직임을 하도록 만들어주었다. 이번에는 나와 충돌하는 걸 형이 인지할 수 있도록 TriggerComponent를 형에게 추가해주자.

4. 이제 Bbing Component에 유저가 충돌이 감지될 때마다 넉백 이벤트와 HP가 감소하도록 만들어주자!

추가적으로 우리는 예의 동방 지국에 살기 때문에 충돌하면 형님께 사과를 즉시 드리도록 하자!

위 코드에 대한 설명을 해보겠다.

설명이 조금 기니 다들 착석해주길 바란다.

착서어억!

먼저 Entity Event Handler 오른쪽 + 버튼을 눌러서 HandlerTriggerEnterEvent 함수를 추가해주었다.

이 함수는 TriggerComponent를 가진 Entity와 충돌 이벤트가 발생하였을 경우 감지해주는 함수입니다.

그다음 넉백 이벤드 구현을 위해 if - else문을 작성해주었다.

self.Entity.PlayerControllerComponent는 플레이어 자신의 PlayerControllerComponent를 의미한다.
PlayerControllerComponent에는 LookDirectionX라는 Property를 가지고 있다. 이 Property는 Entity가 오른쪽을 바라보고 있을 경우 양수의 값을 가지고 왼쪽을 바라보고 있을 경우 음수의 값을 가지게 된다.
이를 이용해서 오른쪽을 보고있을 때와 왼쪽을 보고있을때의 구문을 따로 작성할 수 있다.
- self의 의미는 해당 Entity가 가진 값을 스스로 참조하고 싶을 때 사용하며, 변수를 참조할 때는 self.변수명, 함수를 참조할 때는 self:함수명으로 참조한다.
RigidbodyComponent는 Addforce라는 함수를 가지고 있다. 함수이기 때문에 세미콜론으로 참조해주었고, Addforce 라는 함수는 함수 인자로 벡터를 받게 된다.
- Vector2는 2차원 벡터로 첫번째 좌표가 x축, 두번째 좌표가 y축을 의미한다고 생각하면 된다.
첫 if문은 유저가 오른쪽을 보고있다면 왼쪽으로 넉백시켜! 그다음 else문은 유저가 왼쪽을 보고있다면 오른쪽으로 넉백시켜! 라는 뜻이다.

그다음 self.Entity.PlayerComponent.Hp 구절은 충돌 감지시 100씩 체력을 감소하는 구절이다.

마지막 구절은 충돌 감지시 유저가 특정 말을 말풍선으로 출력하도록 만드는 구절이다!

영상으로 한번 잘 구현되었나 보도록 하자!

도키 도키

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

형과 닿자마자 공손하게 사과드리는 훈훈한 모습이다.

짜식

이제 마지막으로 Create Logic에 대해서 알아보자

Logic은 기본적으로 게임을 만들게 되면 딱 한개만 존재할수있다.

또한 Logic은 작성하고나면 따로 추가하지 않아도 자동으로 실행된다.

Logic은 간단한 코드로만 알아보자!

void OnBeginPlay()
{
	--현재 컴포넌트의 엔티티의 transformComponent의 position 값을 갖고옴
	local myEntityPosition = self.Entity.TransformComponent.Position
	log(myEntityPosition)

	--컴포넌트가 적용된 엔티티의 위치 변경
	for count=1, 10, 1 do
		myEntityPosition.x = myEntityPosition.x + 0.5
		myEntityPosition.y = myEntityPosition.y + 0.5
		wait(1)
	end

	--컴포넌트가 적용된 엔티티의 크기 변경
	self.Entity.TransformComponent.Scale.x = 2
	self.Entity.TransformComponent.Scale.y = 2
}

OnBeginPlay는 위에서 설명했듯 컴포넌트가 시작(초기화)하자마자 호출되는 함수이고, 위 코드는 1초 간격으로 TransformComponent를 가지고있는 Entity들의 위치와 크기를 변경해주는 코드이다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

사랑해요 여러분

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 5 회고

개발자Dongbaek — Wed, 13 Jul 2022 01:40:42 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 2주차 12일 회고

그럼 오늘도

달려보자~!!!

Chapter 5은 기본, 그리고 자주 사용하는 컴포넌트들에 대해서 배웠다.

배웠던 컴포넌트들을 우리의 PTSD를 일으킬 재밌는 예시들을 보며 쉽게 한번 배워보자

내 1주차 회고를 봤던 사람이라면 내가 만든 맵이 무엇인지 알 것이다.

...

..

1주차 안봤다고?

정말로...?

1주차 봐주세요ㅠㅠ

아래는 1주차 회고 주소이다.

아... 볼 생각 없다고?

그렇지...

그럴수도 있지...

한 번만 들어와주세요 ㅠ

https://devdongbaek.tistory.com/132

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 1주차 회고

devdongbaek.tistory.com

아래 사진은 1주차 당시 내가 만든 맵이다.

우리의 학창 시절이 생각나지 않는가?

위에는 타일, 중학생 형, 너 나 우리 Entity가 존재한다.

Entity들은 모두 컴포넌트들을 지니고있다.

컴포넌트는 엔티티의 성질 및 기능을 결정하는 것이라 생각하자.

위의 토끼는 오브젝트이다.

여러분은 위 토끼 같은 친구를 골목에서 만난적있는가?

나를 왜불렀었니 토끼야...

포켓몬스터 게임을 해보면 길가를 걸어가다 NPC를 만나게 되면 강제적으로 이벤트가 발생하게 된다.

토끼도 마찬가지다

나에겐 선택권이 없다.

본인은 잼민이 시절 토끼같은 친구로 인해 자주 뒷골목에 징집되고는 했다.

내가 과거를 돌아가서 토끼를 만나지 않게 하는 방법은 어떻게 해야할까??

첫번째 방법으로는 토끼가 나를 못보게 하면 된다.

이를 위해 첫번째로 알아볼 컴포넌트는

TransformComponent

이다.

TransformComponent 는 오브젝트가 월드 어디에 표시되는지 위치 정보를 가지고 있다. 특수한 형태를 제외하고는 모두 지니고있다.

TransformComponent은 오브젝트의 크기를 scale값 조정을 통해 조절할 수 있다.

y값을 3배 키움으로써 토끼의 키를 3배 크게 만들었다.

하지만 토끼가 고개를 숙이면 나를 볼수도있다. 그러면 이 방법은 좋은 방법이 아니다.....

애초에 이 크기면 너가 형좀 혼내줘....ㅠㅠㅠㅠ

TransformComponent은 오브젝트의 위치를 Position을 통해 조정할 수 있다.

이를 통해서 토끼를 먼 곳으로 보내버리자.

토끼도 잡혀버렸다....

왜 잡혀가지고

내가 아무리 쓰레기라 하더라도 친구를 잡히게 할 수는 없다.

그러면 토끼가 나를 못보게 회전시킨다면 어떨까???

TransformComponent은 오브젝트를 Rotation을 통해 회전시킬 수 있다.

World는 절대좌표를 기준으로, Z는 상대좌표를 기준으로 회전한다.

토끼가 땅에 쳐 박혀버렸다...

이 방법은 좋은 방법은 아닌 것 같다..

그렇다면 토끼를 토끼가 아닌 다른 캐릭터로 바꾸면 어떻게 될까? 그렇다면 토끼와 내가 만나지 않게 되는거 아닌가..?

지니어스

SpriteRedererComponent은 엔티티에 어떤 이미지를 표시할 것인가를 의미한다.

SpriteRendererComponent에는 SpriteRUID Property가 있는데 이는 오브젝트의 각 고유한 번호를 의미하며, 이미지를 id 형태로 관리하는 것을 말한다.

토끼의 SpriteRUID를 다른 오브젝트의 고유한 번호로 바꾸면 우리는 드디어 무시하고 지나갈 수 있을 것이다!!!!

?????????

???

아니 토끼는 그대로인데...?

??? : 아니 잠깐만.... 그냥 토끼가 뒤돌면 되는거 아님???

나 : ?

그러네요

SpriteRendererComponent에는 FlipX / FlipY Property가 있는데 이는 오브젝트를 X축, Y축을 기준으로 뒤집을 수 있는 기능이다.

토끼가 불쌍하긴 하지만.....

문제 해결 >3<

뚜둔!

근데 여러분 동네의 무서운 형, 누나들은 위 맵의 중학생 형처럼 가만히 있으며 돈을 수금했는가??

그럴수도 있지만 본인 동네의 형님들께서는 부지런히 출장을 자주 다니셨다.

이쯤되면 어떤 삶을 살아온건가

과거 애인을 찾듯 우릴 찾아 헤매던 방방곡곡을 다니던 그리운(?) 형님을 구현해보자

형님이 나를 찾을때의 그 미소가 안잊힌다.

형님을 움직이게 하기위해 첫번째로 알아볼 컴포넌트는

TweenLineComponent

이다.

TweenLineComponent은 선형 애니메이션을 다루는 컴포넌트라고 생각하면 된다. 목적지 위치를 지정한 다음 종료 방식을 선택하고, 해당 Entity가 원하는 범위를 반복적으로 움직이게 할 수 있다.

여러 property가 있지만 우리는 형님이 왼쪽 방향으로 왕복 순찰(?)을 직선 방향으로 하는 것이 목적이기에 아래 적힌 property들을 수정해준다.

Position을 x : -5, y : 0으로 설정하면 왼쪽으로 5만큼 이동한 후 원래 자리로 돌아온다.
StopType에는 OneRoundTrip과 RepeatRoundType이 존재하는데, OneRoundTrip은 한번만 반복하는 것, RepeatRoundType은 계속 반복하는 것을 정의한다.

여담으로 제일 중요한 것은 SyncType, 즉 동기화 방식인데 옵션들은 아래와 같다.

ClientOnly : 동기화가 안된 상태.
Default : 동기화가 되어 있는 상태.
동기화가 잘 되어 있어야 유저 여러명이 함께 플레이를 할 때 동일한 화면에서 동일하게 플레이 할 수 있음.
목적에 맞게 Sync 조정을 잘해주어야 한다. 예를 들어 중학생 형이 유저들마다 모두 다른 위치에 있는 것으로 보이면 곤란하지않겠는가? 이런 경우 SyncType을 Server로 설정하여 모든 플레이어에게 동일하게 보이게끔 만들 수 있다.

아래는 형님에게 TweenLineComponent를 적용시킨 모습이다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

TweenLineComponent 말고도 움직임을 제어하는 컴포넌트들은 정말 많다.

컴포넌트 진짜 너무 많아...

하나 하나 이야기하기에는 너무 기니까

자세한 거는 공식문서를 살펴보자

https://mod-developers.nexon.com/ko/apiReference/Components

https://signin.nexon.com/signin?redirect_uri=https://mod-developers.nexon.com/ko/apiReference/Components

signin.nexon.com

봐주세요

각 컴포넌트를 적용한 형님의 움직임 영상을 보도록하자

TweenCircularComponent : 회전 움직임을 제어

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

TweenFloatingComponent : 부유 운동 방식 설정 가능

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

RigidbodyComponent : 강체의 물리적인 속성을 컨트롤 할 수 있다.

RigidbodyComponent는 중력과 타일이나 벽이 세로로 쌓여있을 경우 지나갈 수 없게 만든다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

mod component들을 만든 모두에게 존경을

정말 정말 더 많은 컴포넌트들이 있는데

하나 하나 이야기 다 못한게 좀 아쉽다.

그래도 멍청한 나의 설명보다 공식문서에는 더 정확하고, 이해하기 쉽게 설명이 나와있으니

다들

참고(풀거나 나타내지 않고 억누르다),

참고 (살펴서 도움이 될 만한 재료로 삼음)바란다.

정보 : 동음이의어를 사용한 개그

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 좀 웃겼다. 인정?

기력이 다했나봅니다.

Chapter 6는 스크립트에 대해서 이야기 해보겠다.

오늘도 부족하디 부족한 글 보느라 정말 감사하고, 제발 또 봤으면 좋겠다.

꼭 다시 놀러와주라!

제발요

또 봐요 여러분

DRF mixins 상속을 통한 APIView

개발자Dongbaek — Tue, 12 Jul 2022 01:32:36 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Mixin : 전통적인 다중 상속을 클래스의 부분 부분을 쪼개어 조립하는 것

DRF에서 지원하는 mixins

파이썬에서는 mixin이라는 문법은 따로 없고, 상속 문법을 사용하여 구현된다.
믹스인 클래스는 직접적으로 사용하는게 아니라 다른 클래스에 의해서 상속이 되어 사용된다.
믹스인에는 create(), list() 등의 리소스를 생성하거나 가져오는 로직이 구현되어있다.
로직만 구현되어 있을 뿐, http method와 연계하는 부분은 직접 연결해줘야 한다.
- CreateModelMixin : Create를 하는 일반적인 로직이 구현되어 있음.
- ListModelMixin : 목록을 조회하는 로직
- RetrieveModelMixin
- UpdateModelMixin
- DestroyModelMixin

CreateModelMixin

class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        
        # 유효성 검사 통과를 못하면 예외가 발생
        serializer.is_valid(raise_exception=True)  
        
        # serializer 저장
        self.perform_create(serializer) 
        
        # 성공했을 때 응답 해줄 헤더 목록을 헤더에 넣는다.
        headers = self.get_success_headers(serializer.data)  
        
        # 응답을 리턴
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)  

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

Http method에 따른 처리를 따로 구현 해주어야한다.

method별 로직 연결

from rest_framework import generics
from rest_framework import mixins
class PostListAPIView(mixins.ListModelMixin, mixins.CreateModelMixin, generics.GenericAPIView):  # generics.GenericAPIView가 가장 마지막에 상속받아야 한다.
    queryset = Post.objects.all()
    serializer_class = PostSerializer
	
    # Http method가 get일 때, self.list를 호출하겠다라고 매핑
    def get(self, request, *args, **kwargs):  
        return self.list(request, *args, **kwargs)  # mixins.ListModelMixin을 상속받아서 사용 가능
	
    # Http method가 post일 때 self.create를 호출하겠다라고 매핑
    def post(self, request, *args, **kwargs):  
        return self.create(request, *args, **kwargs) # mixins.CreateModelMixin을 상속받아서 사용 가능

ListModelMixin과 CreateModelMixin을 상속 받았기에 list와 create라는 멤버 변수가 생성된다.
get -> self.list, post -> self.create를 매번 같은 파라미터를 넘겨 연결하려니 번거롭다.

from rest_framework import generics
from rest_framework import mixins
class PostDetailAPIView(mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixi, generics.GenericAPIView):  # generics.GenericAPIView가 가장 마지막에 상속받아야 한다.
    queryset = Post.objects.all()
    serializer_class = PostSerializer

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

모든 Http method마다 직접 연결을 해야하니 번거롭다. 심지어 하나가 늘어남.

APIView의 일반적인 로직을 섞어서 재사용율을 높인게 mixins

mixins들보다 패턴화 한것이 Genenrics

Genenrics들을 더욱 정리한게 ViewSet이다.

여러 generic APIView (모두 GenericsAPIView 상속)

genenrics.APIView이름 : Http method -> 멤버 함수
generics.CreateAPIView : post → create
generics.ListAPIView : get → list
generics.RetrieveAPIView : get → retrieve
generics.DestroyAPIView : delete → destroy
generics.UpdateAPIView : put → update, patch → partial_update
generics.ListCreateAPIView : get → list, post → create
generics.RetrieveUpdateAPIView : get → retrieve, put → update, patch → partial_update
generics.RetrieveDestroyAPIView : get → retrieve, delete → destroy
generics.RetrieveUpdateDestroyAPIView : get → retrieve, put → update, patch → partial_update, delete → destroy

generic APIView 활용

from rest_framework import generics
class PostListAPIView(generics.ListCreateAPIView):  # 아래 ListCreateAPIView를 상속
    queryset = Post.objects.all()
    serializer_class = PostSerializer

# rest_framework/generics.py
class ListCreateAPIView(mixins.ListModelMixin, mixins.CreateModelMixin, GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

generics.ListCreateAPIView를 상속받아서 PostListAPIView를 구현한다.

from rest_framework import generics
class PostDetailAPIView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

# rest_framework/generics.py
class RetrieveUpdateDestroyAPIView(mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

generics.RetrieveUpdateDestroyAPIVie를 상속받아서 PostDetailAPIView를 구현

적절한 generics APIView를 상속받기만 해도 원하는 기능을 구현할 수 있다.

직접 API View를 만들 수 있을 정도로 공부하기(내부를 이해하기 위해서)

ViewSet이 좋다고, ViewSet만 공부해서는 나중에 응용할 수 없다.

DRF로 APIView, Json 응답뷰 만들기

개발자Dongbaek — Mon, 11 Jul 2022 23:02:21 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

ModelSerializer를 통한 JSON 직렬화

_Serializer / ModelSerializer은 Form / ModelForm과 유사합니다.

-> 역할 면에서 Serializer은 POST 요청만 처리하는 Form

둘의 공통점
- 폼 필드 지정 혹은 모델로부터 읽어오기.
- 입력된 데이터에 대한 유효성 검사를 통해 저장합니다.
둘의 차이점
- Form / ModelForm : Form태그가 포함된 HTML을 생성합니다.
- Serializer / ModelSerializer : Form 데이터가 포함된 JSON 문자열을 생성합니다.

Serializer를 통한 뷰처리(DRF를 사용하지 않을 때)

from rest_framework.serializers import ModelSerializer

# Post모델에 대한 ModelSerializer 정의
class PostSerializer(ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

# Views
serializer = PostSerializer(data=request.POST)
if serializer.is_valid():
	# 유효성 검사에 통과한 값들을 전달
	return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)

Form 생성자의 첫번째 인자는 data이지만, Serializer 생성자의 첫번째 인자는 instance이다.

DRF의 기본 CBV인 APIView

APIView 클래스 혹은 @api_view장식자
View에 여러 기본 속성을 부여한다.
1. renderer_classes: 직렬화 class 다수
2. parser_classes: 비직렬화 class 다수
3. authentication_classes: 인증 class 다수 -> 유저를 식별하는 것
4. throttle_classes: 사용량 제한 class 다수(호출 제한)
5. permission_classes: 권한 class 다수 -> 유저를 식별하고 나서 각 자원에 대해 접근 레벨을 정의
6. content_negotiation_class: 요청에 따라 적절한 직렬화/비직렬화 class를 선택하는 class
7. metadata_class: 메타 정보를 처리하는 class
8. versioning_class: 요청에서 API버전 정보를 감지하는 class
각 옵션의 디폴트 값
1. renderer_classes
  - rest_framework.renderers.JSONRenderer : JSON 직렬화
  - rest_framework.renderers.TemplateHTMLRenderer : HTML 페이지 직렬화
2. parser_classes
  - rest_framework.parsers.JSONParser : JSON 포맷 처리
  - rest_framework.parsers.FormParser
  - rest_framework.parsers.MultiPartParser
3. authentication_classes
  - rest_framework.authentication.SessionAuthentication : 세션에 기반한 인증
  - rest_framework.authentication.BasicAuthentication : HTTP Basic 인증
4. throttle_classes
  - 빈 튜플 (디폴트로는 요청 횟수 제한이 설정 되어 있지 않음)
5. permission_classes
  - rest_framework.permissions.AllowAny : 누구라도 접근 허용
6. content_negotiation_class
  - rest_framework.negotiation.DefaultContentNegotiation
  - 같은 URL로의 요청이지만, JSON응답을 요구하는 것이냐 / HTML응답을 요구하는 것인지 판단
7. metadata_class
  - rest_framework.metadata.SimpleMetadata
8. versioning_class
  - None: API 버전 정보를 탐지하지 않겠다.
  - 요청 URL에서, GET인자에서, HEADER에서 버전 정보를 탐지하여 해당 버전의 API뷰가 호출되도록 합니다.

APIView와 @api_view

APIView : 클래스 기반 뷰//상속 받아야 함
@api_view : 함수 기반 뷰를 위한 장식자

APIView

하나의 CBV 이므로 -> 하나의 URL만 처리 가능
- 그러나 ApiView를 좀더 표준화-> Generic
- Generic을 좀더 합친 것: ViewSet
- ViewSet은 여러개의 URL의 대응이 가능하다.
- 즉 ApiView와 Generic은 하나의 get, post, put, delete의 url만 매핑 가능하다면 ViewSet은 두개의 url 매핑 가능
각 method(get, post, put, delete)에 맞게 멤버함수를 구현하면, 해당 method 요청이 들어올 때 호출. 호출 이전 단계(initial)에서 다음을 처리함
- // APIView를 상속받을 때 자동으로 처리되는 작업들
- 직렬화 / 비직렬화 처리(JSON 등)
- 인증 체크
- 사용량 제한 체크: 호출 허용량 범위인지 체크
- 권한 클래스 지정: 비인증/인증 유저에 대해 해당 API 호출을 허용할 것인지를 결정
- 요청된 API버전 문자열을 탐지하여, request.version에 저장

클래스 형태) APIView 구현 샘플

get, post등을 직접 구현 하였으나 직렬화, 인증 등은 APIView에 포함되어있고, 우리는 그것을 상속 했으므로 직접 구현하지 않아도 된다.

list / create

from rest_framework.response import Response
from rest_framework.views import APIView
from .models import Post
from .serializers import PostSerializer

class PostListAPIView(**APIView**):
    def get(self, request):
        qs = Post.objects.all()
        serializer = PostSerializer(qs, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = PostSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

detail / update / delete

from django.shortcuts import get_object_or_404
from rest_framework.response import Response
from rest_framework.views import APIView
from .models import Post
from .serializers import PostSerializer
class PostDetailAPIView(**APIView**):
    def get_object(self, pk):
        return get_object_or_404(Post, pk=pk)

    def get(self, request, pk, format=None):
        post = self.get_object(pk)
        serializer = PostSerializer(post)
        return Response(serializer.data)

    def put(self, request, pk):
        post = self.get_object(pk)
        serializer = PostSerializer(post, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, pk):
        post = self.get_object(pk)
        post.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

위 메소드들은 무슨 프로젝트를 진행하더라도 거의 비슷하게 작성되고, 반복된다. 이를 패턴화 한게 generics이고, generics를 합쳐서 구조화 시킨 것을 viewset이라 한다.

# rest_framework/views.py
from django.views.decorators.csrf import csrf_exempt
class APIView(View):
    # …
    @classmethod
    def as_view(cls, **initkwargs):
        # …
        **return csrf_exempt(view)

뷰가 csrf_exempt 장식자로 이미 감싸져있기에 POST 요청에서 csrf token 체크를 하지 않습니다.
이를 이해하기 위해서 파이썬 장식자를 공부할 필요가 있다!!!

함수 형태) @api_view 장식자 구현 샘플

하나의 작업만을 구현코자 할 때 @api_view를 쓰면 편리하다.

List / create

from django.http import get_object_or_404
from rest_framework import status
from rest_framework.response import Response
from rest_framework.decorators import api_view
from .models import Post
from .serializers import PostSerializer

# 나는 어떤 인자를 지원하겠다라고 명시
# 인자를 비우면 매칭되지 않음
**@api_view**(['GET', 'POST'])  
def post_list(request):

    if request.method == 'GET':
        serializer = PostSerializer(Post.objects.all(), many=True)
        return Response(serializer.data)
    else:
        serializer = PostSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

함수형 뷰에서는 각 요청을 if문으로 처리한다.

detail / update / delete

from rest_framework.decorators import api_view
from rest_framework.response import Response

**@api_view**(['GET', 'PUT', 'DELETE'])
def post_detail(request, pk):
    post = get_object_or_404(Post, pk=pk)

    if request.method == 'GET':
        serializer = PostSerializer(post)
        return Response(serializer.data)

    elif request.method == 'PUT':
        serializer = PostSerializer(post, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    else:
        post.delete()
    return Response(status=status.HTTP_204_NO_CONTENT)

https://www.django-rest-framework.org/api-guide/fields/

Serializer fields - Django REST framework

www.django-rest-framework.org

https://velog.io/@kmnkit/drf-rwonly

Serializer 필드 작성 방법

Serializer를 쓸 때 헷갈리는 필드 정하는 방법.

velog.io

serializer field를 통해 읽기만 해야하는 필드, 쓰기만 해야하는 필드, 둘 다 해야하는 필드로 나눌 수 있다.

혼자만의 깨달음

왜 DRF의 페이지에서는 해당 페이지로 보내진 API(JSON)만 보이고, 기존 Django에서 보이던 페이지들이 왜 안보이지라고 생각했었는데 정말 무지했다.

DRF의 목적은 프론트단에 API를 보내주는게 목적이거늘 Django처럼 풀스택만을 지원한다고 생각했던 것이 패착이었다.

이 이유로 DRF의 view단에서 return response를 보내줄 때 html을 render하지 않고 data만 보내준다.

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 1~4 회고

개발자Dongbaek — Mon, 11 Jul 2022 18:55:22 +0900

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon Chapter 1주차 11일 회고

시작해봅시다!

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 1주차 11일 회고

mod의 기본적인 인터페이스

1주차에는 MOD 클라이언트의 기능 및 구성에 대해서 배웠다. 위 사진에 볼 수 있다 싶이

기본적인 홈,

플레이,

배경,

나에게는 필요 없는 친구창,

그리고 메이플을 한번이라도 했던 유저라면 빼먹을수 없는

아바타(일명 메이플 코디 및 룩X)가 있다.

최고다 MOD!!!!

아바타를 나는 MOD를 해야만 하는 세가지 이유 중 하나로 뽑았다..!!

주최측분들께서 멋사 X MOD 해커톤 참여자에게 임의의 캐쉬를 지급하기로 해주셨지만...

아직 내 캐릭터는 30도를 넘는 날씨 때문인지 아니면 빈 지갑 때문인지 헐벗어있다.....

...

빈 지갑 때문인지

빈 지갑 때문인지

실 본인 헤어스타일과 상당히 유사하다.

그래도 지갑이 가난한 유저들을 위해 넥슨은 맘에드는 옷을 몸위에 걸쳐볼 수는 있는 기회를 감사하게 주셔서 테일즈런너와 메이플을 할 때 나름 짬먹은 코디 실력을 살려 꾸며보았다.

나름 귀여울지도..?

옷을 입고나서 가난한 나는 쫓겨나듯 옷을 반납(강탈 당)하고 다시 홈으로 돌아왔다.

삐짐을 나름대로 표현했다.

플레이를 나는 MOD를 해야만 하는 세가지 이유 중 하나로 뽑았다..!

플레이는 위와 같이 구성되어있다.

그냥 랜덤하게 하나 들어가기로 해보았다.

정말 랜덤하게

정말로

사심 없이

정말 사심없이

룰은 아래와 같다한다.

사실 좀 설렌다.

본인에게 프로듀스란 내 최애그룹

"아이즈원"을 만들어준 소중한 프로그램이다.

최고다.. 아니 최고였다 아이즈원!!!

거두절미 하고 플레이해보겠다.

들어가자 마자 느껴지는 인싸들의 향기에 취한다.

모두 파티에 온다고 나름대로 꾸민 모습이

애처롭기까지

한다...

그들은 내가 무대에 들어선 순간 모두 조용해지고, 나만을 위한 무대가 완성된다..

이 몸 등장

참여하고나서 경쟁자들의 용모를 살펴보았다.

아름답지만.... 아냐..

나름대로 힘을 주었지만 아니 이건 내가 추구하는 것과 달라

?...

다들 내 마음에는 들지 못하였지만 한 친구가 내 눈에 들어왔다.

맘에 들었지만 곁눈질로 계속 스캔해보았다.

나름 이 친구 괜찮을지도..?

나름 옆에 끼고 다닐만한 비주얼을 소유했기에 기꺼이 투표를 눌러주었다. 만약 언젠가 위 유저가 이 글을 보게 된다면 댓글을 달아주길 바란다.

동묘로 같이 옷 사러가자.

그다음 MOD의 핵심중의 핵심 만들기 기능을 이야기해보겠다..!

만들기를 나는 MOD를 해야만 하는 세가지 이유 중 하나로 뽑았다..!

...

지금 배고파서 글이 안써지기에 밥을 먹고 만들기를 이어서 이야기해보겠다..!!!

배를 채우고 다시 돌아왔다.

만들기에 이어 말해보겠다.

여러분은 스타 유즈맵을 만들어본적 있는가...?

만들어본적 없다면....

직접 코드를 작성할 수 도 있지만 위 사진의 왼쪽에 위치한 Model List에 위치한 Model들을 끌어다 위치시킬 수 있다.

위는 대략적으로 우리 모두의 학창시절을 떠올리게 하는 맵을 만들어보았다.

아니라고?

나만 PTSD 떠오르는 거라고?

나만 맞았나봐

MOD는 내가 만든 맵을 도중도중 PLAY 버튼을 통해 직접 플레이 할 수 있다.

위는 내가 만든 MOD world를 직접 실행 버튼을 눌러 실행시킨 모습이다.

위에서 타일과 중학생형과 맞고있는 우리는 모두 Entity라 한 것 기억하는 가?

Entity는 모두 컴포넌트를 지니고 있다.

컴포넌트는 엔티티의 성질 및 기능을 결정하는 것이라 간단하게 생각해도 좋다.

중학생형은 초반에는 말을 할 수 없다. 왜냐하면 Chat을 도와주는 컴포넌트가 없기 때문이다.

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

그래도 불쌍하니 말풍선을 만들어주는 컴포넌트를 만들어주자

위 ChatBalloonComponent가 말풍선을 만들어주는 컴포넌트이다.

그리고 위의 FontColor나 Message를 Property라 부른다.

Property는 컴포넌트의 세부적인 작동을 설정할 수 있다.

만들어주면 위 사진같이 형이 말을 할 수 있게 된다.

............................

............

...

부족한 글 봐주셔서 감사드립니다.

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 1주차 11일 회고 정리

아래는 보안에 의해서 비공개 처리되어있습니다.

https://devdongbaek.tistory.com/130

멋쟁이사자처럼 X 넥슨 MOD Suppoters Hackathon 1주차

devdongbaek.tistory.com

11729번: 하노이 탑 이동 순서

개발자Dongbaek — Mon, 23 May 2022 21:47:52 +0900

하노이 탑 이동 순서 성공

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

256 MB

57592

28704

22195

49.418%

문제

세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다. 이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로 옮기려 한다.

한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.
쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다.

이 작업을 수행하는데 필요한 이동 순서를 출력하는 프로그램을 작성하라. 단, 이동 횟수는 최소가 되어야 한다.

아래 그림은 원판이 5개인 경우의 예시이다.

입력

첫째 줄에 첫 번째 장대에 쌓인 원판의 개수 N (1 ≤ N ≤ 20)이 주어진다.

출력

첫째 줄에 옮긴 횟수 K를 출력한다.

두 번째 줄부터 수행 과정을 출력한다. 두 번째 줄부터 K개의 줄에 걸쳐 두 정수 A B를 빈칸을 사이에 두고 출력하는데, 이는 A번째 탑의 가장 위에 있는 원판을 B번째 탑의 가장 위로 옮긴다는 뜻이다.

내 정답 코드

# n -> 옮겨야 할 원반의 개수 x -> 시작 기둥의 번호 y -> 목표 기둥의 번호
# k -> 첫째 줄에 옮긴 횟수

# 이미 함수로 넘길 때 이동을 시키기에 1에서 시작
k = 1


# x들이 들어있는 리스트
starts_list = []


# y들이 들어있는 리스트
goals_list = []


"""
    기본 프로세스
    ex) 원반이 3개일 때
    n : x -> y

    1. 바닥에 있는 원반을 제외한 그룹을 시작 기둥에서 중간 기둥으로 옮깁니다.
        1 -> 3
        1 -> 2
        3 -> 2
    
    2. 바닥에 있는 원반을 시작 기둥에서 목표 기둥으로 옮깁니다.
        1 -> 3

    3. 바닥에 있는 원반을 제외한 그룹을 중간 기둥에서 목표 기둥으로 옮깁니다. 
       2 -> 1
       2 -> 3
       1 -> 3
"""


def hanoi(n, x, y):
    # 전역변수 k를 함수 내에서 사용하기 위해서 global 선언
    global k
    
    # 1. 바닥에 있는 원반을 제외한 그룹을 시작 기둥에서 중간 기둥으로 옮깁니다.
    if n > 1:
        # (2, 1, 2) -> (1, 1, 3), (1, 3, 2)
        hanoi(n - 1, x , 6 - x - y)
        k += 1
    
    # n = 1, 즉 원반이 1개 남았을 때 시작, 목표 기둥 저장
    # 2. 바닥에 있는 원반을 시작 기둥에서 목표 기둥으로 옮깁니다. 
    # (3, 1, 3)
    starts_list.append(x)
    goals_list.append(y)
    
    # 3. 바닥에 있는 원반을 제외한 그룹을 중간 기둥에서 목표 기둥으로 옮깁니다. 
    if n > 1:
        # (2, 2, 3) -> (1, 2, 1), (1, 1, 3)
        hanoi(n - 1, 6 - x - y  , y)
        k += 1


n = int(input())

hanoi(n, 1, 3)

print(k)

for i in range(len(starts_list)):
    print(f"{starts_list[i]} {goals_list[i]}")

멋쟁이사자처럼 장고 강의 정리

개발자Dongbaek — Thu, 19 May 2022 16:53:26 +0900

장고에 필요한 파이썬의 핵심 문법들

1. 자료형(딕셔너리)

대응이 되는 데이터를 표현해주고 싶을 때 사용

2. 예외처리

문법 에러(파싱 에러) : 실행 자체에 영향을 주는 치명적인 오류
예외 : 실행중 감지되는 오류, 프로그램 실행 자체를 멈추지는 않는 오류
프로그램을 에러로 인해 멈춤 없이 사용하고 싶을 때 사용

 try:
 	# 일단 시도해 볼 것
        # 오류가 생길 여지가 있는 코드
 except 발생 오류:
 	# 발생 오류가 발생했을 때 실행할 코드
 finally:
 	#예외가 발생했든 안했든 최종적으로 실행할 코드

3. 클래스와 객체

이 세상에 있는 것들은 모두 상태와 동작으로 나타낼 수 있다.
상태 -> 변수, 동작 -> 함수
상태와 동작을 한번에 여러 개 정의할 수 있는 방법 -> 객체 지향 프로그래밍

class Panda():
	hp = 10
    
    def move():
    	pass
    
    def attack():
    	pass
        
        
 # 객체
 
 panda1 = Panda()
 panda2 = Panda()
 panda3 = Panda()

4. 모듈, 패키지, 라이브러리

모듈 -> 파이썬으로 정의된 파일 ex) a.py, b.py

# a.py
def sum(a, b):
	return a+b
    

# b.py
import a
a.sum(1, 2)

패키지 -> 모듈의 집합(폴더), 모듈의 계층 단위

# a.py가 data 폴더에 있을 때 data == 패키지
def sum(a, b):
	return a+b
    

# b.py
import data.a
a.sum(1, 2)

라이브러리 -> 쓸 만한 기능들을 미리 모듈 / 패키지로 만들어 놓은 것 ex) 내장함수, pip
사람들이 만든 라이브러리는 PyPI에 저장되고, 라이브러리를 설치할 때 pip를 이용한다.

웹 서비스란?

웹 -> 정보의 그물망
URL -> 정보 자원이 어디있는지 나타내는 표식
HTTP -> 정보 자원으로 접근하고 통신하게 해 주는 약속
- GET -> 정보 자원을 가져다줘!
- POST -> 이 데이터를 처리해줘!
HTML -> 응답으로서의 정보 자원 자체, a태그를 통한 다른 정보 자원가 연결 매개체
Server -> 요청을 예상하고, 그에 따른 정보 자원을 미리 저장해놓고 제공하는 것
웹 서비스란? HTML과 URL을 미리 준비해놓고, 사용자 요청에 대한 응답을 보낼 수 있는 프로그램

웹 프레임워크란?

프레임워크 -> 복잡한 문제를 해결하거나 서술하는데 사용되는 기본 개념 구조
더 쉬운 말로 정형화 되어있는 웹 개발을 반복되는 코드 작업을 효율적으로 하기위해 미리 만들어 놓은 웹개발의 기능, 설계 단위의 집합
프레임워크(django) -> 명확한 목적을 달성하기 위해 이미 설계까지 만들어진 구조, 틀을 무조건 지켜야함
라이브러리(react) -> 도구의 모음

MVC, MTV란?

MVC 디자인 패턴(장고에서는 MTV 패턴이라고 부름)
- 1. DB와 상호작용하는 부분 -> model, model(장고 기준)
- 2. 사용자들 눈에 보이는 부분 -> view, templates(장고 기준)
- 3. 내부 동작의 논리를 담당하는 부분 -> controller, view(장고 기준)

https://beomy.tistory.com/43

[디자인패턴] MVC, MVP, MVVM 비교

웹 개발자로 일을 하면서 가장 먼저 접한 디자인패턴이 바로 MVC 패턴이었습니다. 그만큼 유명하고 많이 쓰이는 디자인패턴인 MVC 패턴과 MVC 패턴에서 파생되어져 나온 MVP 패턴과 MVVM 패턴을 이야

beomy.tistory.com

가상환경이란?

독립적인 개발환경 만들기
- 버젼 충돌이나 여러 상황들로부터 독립적인 환경을 만들어줌.
- 1. 가상환경 생성
  - python -m venv 가상환경이름
- 2. 가상환경 실행
  - source myvenv/Scripts/activate
- 3. 가상환경 끄기
  - deactivate

장고의 기본 파일들

__init__.py란

__init__.py가 위치한 곳이 패키지라는 것을 알려주는 파일

urls.py란

url들을 매핑해주고, 관리해주는 곳

장고 프로젝트 시작하기

django-admin startproject 프로젝트명

manage.py란

1. 서버 켜기

python manage.py runserver

2. Application 만들기
- Application : 하나의 장고 프로젝트를 이루는 단위 ex) 결제기능앱, 게시판기능앱

python manage.py startapp 앱이름

3. Database 초기화 및 변경사항 반영

python manage.py migrate

4. 관리자 계정 만들기

python manage.py createsuperuser

settings.py란

여러 설정값을 저장하고, 지정하는 곳

url을 효율적으로 매핑시키는 방법

include를 사용하는 방법 ex) product로 시작하는 url은 product app의 urls.py에서 담당할 것이다.

path('product/', include('product.urls'), name='product'),

product app의 아래 url은 product/first/로 매핑된다.

urlpatterns = [
    path('first/', views.products, name='products'),
]

웹 서비스 내부 데이터

Static : 미리 준비된 데이터
Media : 업로드 된 데이터

static 파일을 관리 하는 법

STATICFILES_DIRS : static 파일들의 경로 작성

static 파일들을 하나의 폴더에서 관리 할 때

STATICFILES_DIRS = [
    BASE_DIR / 'static',  
]

# 최상위 디렉토리 아래 static 폴더를 만들겠다는 의미입니다.

static 파일들을 앱마다 각자의 폴더에서 관리 할 때

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, '앱이름', 'static'),  
    os.path.join(BASE_DIR, '앱이름', 'static'),  
    os.path.join(BASE_DIR, '앱이름', 'static')  
]

STATIC_ROOT : 배포시 static 파일들을 복사하여 모아 놓을 경로

STATIC_ROOT = os.path.join('staticfiles')

python manage.py collectstatic

STATIC_URL : static 파일을 제공할 url

STATIC_URL = '/static/'

장고에서는 최상위 디렉토리는 Base Directory라고 부른다.

템플릿에서 staic 폴더 안의 것을 사용하는 방법

{% load static %} <--- {% %}은 템플릿에서 장고 기능을 사용할 수 있는 템플릿 언어이다.

<link rel ="stylesheet" type="text/css" href="{% static 'css/style.css' %}">

템플릿 언어란?

<a href="{% url 'url name' %}"></a>

템플릿 상속이란?

반복되는 html의 구문을 줄이기 위해서 사용한다.
주로 부트스트랩의 Nav Var을 사용할 때 사용한다.

부모 html

          중복되는 코드 입력


{% block content %}
	자식의 html의 코드가 들어가는 부분
{% endblock %}


	중복되는 코드 입력

자식 html

{% extends '부모.html' %}

{% block content %}
	자식 html만의 코드 작성
{% endblock %}

Model

https://devdongbaek.tistory.com/65

Django의 모델에 대해서

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard 장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생..

devdongbaek.tistory.com

모델 활용 순서

Django model을 통해, 데이터베이스 형상을 관리할 경우

모델 클래스 작성
모델 클래스로부터 변경사항이 담긴 마이그레이션 파일 생성 -> makemigrations 명령
변경사항이 있는 마이그레이션 파일을 데이터베이스에 적용 -> migrate 명령

migrate -> 초기화, 변경사항 적용

admin 사이트에서 object 1, 2, 3이 아닌 object 이름으로 표시되게 하는 법

class Blog(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    date = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title

Html 폼 이용하기

https://devdongbaek.tistory.com/81

Django HTML Form

devdongbaek.tistory.com

<form action="{% url 'create' %}" method="POST">
    {% csrf_token %}
    <div>
        <label for="title">제목</label><br/>
        <input type="text" name="title" id="title">
    </div>
    <div>
        <label for="body">제목</label><br/>
        <textarea name="body" id="body" cols="30" rows="10"></textarea>
    </div>  
</form>

위 코드에서는 팀 이름을 입력하기 위한 텍스트 필드를 단지 한개만 가지는데, 폼이 가질수 있는 입력 요소와 관련 라벨의 갯수에는 제한이 없다. 필드의 type 속성은 어떤 종류의 위젯이 표시될지 정의한다. 필드의 name과 id 가 JavaScript/CSS/HTML에 있는 필드를 확인하는데 사용되고 value는 필드가 처음 표시될 때의 초기값을 정의한다. 관련 팀 라벨은 label태그( 위 코드에서 "제목 : "을 확인)를 이용해 명시된다. 여기서 for필드는 관련된 input의 id값을 포함하고 있다.
submit 타입의 input 태그는 (기본적으로) 사용자가 누를수 있는 버튼으로 표시되는데, 버튼의 동작에 의해 폼의 다른 모든 input 요소의 데이터가 서버로 업로드된다. 폼 속성으로는 데이터를 보내기 위해 사용되는 HTTP method와 서버상에서 데이타의 목적지를 ( action으로) 정의한다:

html form을 database에 저장하는 로직

from django.shortcuts import render, redirect
from django.utils import timezone
from .models import Blog

def home(request):
    return render(request, 'index.html')

# 블로그 글을 저장하는 함수
def create(request):
    if(request.method == 'POST'):
        post = Blog()
        post.title = request.POST['title']
        post.body = request.POST['body']
        post.date = timezone.now()
        post.save()    
    
    return redirect('home')

render 는 템플릿을 불러오고, redirect 는 URL로 이동합니다. URL 로 이동한다는 건 그 URL 에 맞는 views 가 다시 실행될테고 여기서 render 를 할지 다시 redirect 할지 결정할 것 입니다. 이 점에 유의해서 사용하신다면 상황에 맞게 사용하실 수 있을 겁니다.

Django Form

Html Form의 기본 형태

<form action=”데이터가 전달될 주소(요청/이동할 주소)” method=”http 요청 방식"> <input type=”text” name=”title”/>
<button type=”submit”>입력</button>
</form>

form이라는 태그 내에 input 태그, button 태그들로 구성되어 있고 form이 시작되는 form 태그 내부에서는 action과 method의 속성을 기술하도록 되어있다.

Action

입력되는 정보들을 받는 url

Method

HTTP 요청 방식에는 GET / POST / PUT / DELETE 가 있습니다. 보통은 GET / POST를 사용한다.

GET

주소가 노출되어도 괜찮고, 다른 사용자에게 공유가 가능한 정보를 처리할 때 사용

POST

회원가입이나 결제와 같은 다른 사용자와 결제해서는 안되는 정보를 처리할 때 사용

장고에서는 폼을 구성하기 쉽도록 프레임워크단에서 지원하고 있다. 특징은 다음과 같다.

모델 클래스의 모델 정보들과 연동할 수 있다. (binding)
Validation 체크 (입력된 정보들의 유효성 검사)를 쉽게 해준다.
악의적인 데이터를 필터링 한다. (sanitisation)
짧고 간결한 코드로 폼 인터페이스를 구현한다.

https://devdongbaek.tistory.com/83

Django를 더 Django스럽게 만들어주는 Form

devdongbaek.tistory.com

forms

from django import forms
from .models import Blog

class BlogForm(forms.Form):
    # 내가 입력받고자 하는 값들
    title = forms.CharField()
    body = forms.CharField(widget=forms.Textarea)

views

# django form을 이용해서 입력값을 받는 함수
# GET 요청(= 입력값을 받을 수 있는 html을 가져다 줌)
# POST 요청(= 입력한 내용을 데이터베이스에 저장. form에서 입력한 내용을 처리)
# 둘 다 처리가 가능한 함수
def formcreate(request):
    # 입력 내용을 DB에 저장
    if request.method == 'POST':
        # BlogForm 객체를 만들고 인자로 입력한 값들을 넘김
        form = BlogForm(request.POST, request.FILES) 
        # 유효성 검사에 통과했다면
        if form.is_valid():
            post = Blog()
            post.title = form.cleaned_data['title']
            post.body = form.cleaned_data['body']
            # DB에 최종 저장
            post.save()
            return redirect('home')
        
    # 입력내용을 받을 수 있는 html 전달
    else:
        form = BlogForm()
    
    # render()의 세번째 인자로 views.py의 데이터를 딕셔너리 자료형으로 html에 넘겨줄 수 있다.
    return render(request, 'form_create.html', {'form':form} )

Django ModelForm

https://devdongbaek.tistory.com/87

Django ModelForm이란?

devdongbaek.tistory.com

forms

class BlogModelForm(forms.ModelForm):
    class Meta:
        model = Blog
        #fields = '__all__'
        fields = ['title', 'body']

views

def modelformcreate(request):
    # 입력 내용을 DB에 저장
    if request.method == 'POST':
        # BlogForm 객체를 만들고 인자로 입력한 값들을 넘김
        form = BlogModelForm(request.POST, request.FILES) 
        # 유효성 검사에 통과했다면
        if form.is_valid():
            # DB에 최종 저장
            form.save()
            return redirect('home')
        
    # 입력내용을 받을 수 있는 html 전달
    else:
        form = BlogModelForm()
    
    # render()의 세번째 인자로 views.py의 데이터를 딕셔너리 자료형으로 html에 넘겨줄 수 있다.
    return render(request, 'form_create.html', {'form':form} )

    <table>
        {{ form.as_ul }}
    </table>

{{ 인자.as_감쌀태그 }}를 통해서views로 부터 넘겨받은 form 인자를 감싸는 태그를 자동으로 생성할 수 있다.

model 값 update

https://velog.io/@fregataa/django-QuerySet.update-vs-QuerySet.bulkupdate-vs-Model.save

[django] model update

어무해django에서 업데이트, 무엇이 다른가?? QuerySet.bulk_update() QuerySet.update() Model.save()

velog.io

쿼리셋

https://devdongbaek.tistory.com/56

동백 // Django 모델을 통한 조회 ( 기초 )Q

devdongbaek.tistory.com

https://devdongbaek.tistory.com/55

동백 // Django 모델을 통한 조회 ( 기초 )Q

devdongbaek.tistory.com

QuerySet -> 데이터베이스로부터 전달받은 데이터 객체 목록

https://docs.djangoproject.com/ko/4.0/ref/models/querysets/

QuerySet API reference | Django 문서 | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

쿼리셋은 RDBMS의 SELECT 문을 생각하면 된다.

디테일 페이지 만들기

https://devdongbaek.tistory.com/109

Django 포스팅 detail view 구현

devdongbaek.tistory.com

Model을 작성할 때 primary key를 등록하지 않았다면, Django는 id 값이라는 pk를 스스로 만들어 primary key로 등록해준다.

id -> 객체가 데이터베이스에 post 된 순서

<a href="{% url 'url이름' 변수 %}">제목 : {{ i.title }}</a>

url 'url이름' 뒤 오는 변수는 주소 url의 함수에 인자로 넘길 값을 의미합니다.

<a href="{% url 'detail' i.id %}">제목 : {{ i.title }}</a>

프로세스 :

# id는 매개 변수나 인자 값으로 사용되기에 원하는 이름으로 설정가능

!중요한 것은 views나 url에서 사용하는 id는 매개변수이기에 원하는 이름으로 지정가능('url의 <int>:변수'와

'views의 def detail(request, 변수)' 의 이름이 같다는 전제하에) 그러나 html에서는 반드시 {{ 변수.id }} id나 pk로 적어야 한다.

1. url에서 id값이 있는 detail 주소를 받고, detail 함수에 매핑시켜줌

path('detail/<int:id>' , views.detail, name='detail'),

2. detail 함수에서 id 값을 인자로 받고, id번째 글을 데이터베이스로부터 가져와서 detail.html으로 전달

def detail(request, id):
    # id 번째 블로그 글을 데이터베이스에서 가져와서 detail.html로 띄워주는 코드
    # get_object_or_404는 첫번째 인자로 특정 객체를 가져올 데이터베이스,
    # 두번째 인자로는 특정 객체의 pk값을 받습니다.
    blog_detail = get_object_or_404(Blog, pk = id)
    
    return render(request, 'detail.html', {'blog_detail':blog_detail} )

get_object_or_404()는 id값을 이용해 특정 모델 객체 하나만 가져온다.

3. detail.html에서 해당 id 글의 출력

Media 파일 업로드

https://devdongbaek.tistory.com/54

동백 // Django media 파일을 다루는 방법

devdongbaek.tistory.com

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

MEDIA_URL = '/media/'

1. MEDIA_URL = ""

각 media 파일에 대한 URL Prefix #필드명.url 속성에 의해서 참조되는 설정
파일에 대한 url 접근시에 사용된다~!

2. MEDIA_ROOT = ""

파일필드를 통한 저장 시에, 실제 파일을 저장할 ROOT 경로

Django에서 media 다루는 순서 요약하기

1. MEDIA_URL 설정

# settings.py
MEDIA_URL = "/media/"

2. MEDIA_ROOT 설정

# settings.py
MEDIA_ROOT = os.path.join(BASE_DIR, "media")

3. URL 지정

# settings.py 경로의 urls.py
from django.conf.urls.static import static
...
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

4. pillow 패키지 설치

5. media 파일 저장하기

    photo = models.ImageField(blank=True, upload_to='instagram/post/%Y/%m/%d')

6. media 파일 사용하기

<img src={post.photo.url} style="width:100px; height:100px" />
<img src={post.photo.path} style="width:100px; height:100px" />

url은 Django에서 저장한 사진의 주소이고, path는 실제 사진이 저장된 서버 컴퓨터 내에서의 주소이기에 보안상으로 url 사용 권장

댓글 구현하기

https://devdongbaek.tistory.com/118

Django 댓글 구현하기

devdongbaek.tistory.com

class Blog(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    photo = models.ImageField(blank=True, null=True, upload_to='blog_photo')
    date = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title
    
    
class Comment(models.Model):
    comment = models.CharField(max_length=200)
    date = models.DateTimeField(auto_now_add=True)
    # 1:N 관계에서는 N측에 1의 기본키를 가져와 외래키로 구성한다.
    post = models.ForeignKey(Blog, on_delete=models.CASCADE)

외래키 같은 경우는 데이터베이스 수업 참조

commit=False를 쓰는 이유는?

예를 들어서 필드가 4개가 있는 모델을 모델 폼으로 작성을 받을 때

나는 그 중 1개의 필드만 폼으로 작성하고 싶다!!

이 경우에 view 함수에서 유효성 검사 이후 form.save()를 먼저 하면 나머지 필드들은 값을 받지

못했으므로 오류가 발생합니다!

그러기에 우리는 장고에게 잠시만 저장을 미뤄줘~~! 라는 의미로 commit=False를 적어준 다음

나머지 필드들의 값을 지정해주는겁니다!

{% for comment in blog_detail.comment_set.all %}

1:N에서 1측의 특정 객체를 참조하고있는 N측의 집합을 모두 가져오고 싶을 때 필드_set.all 사용

로그인, 로그아웃 구현하기

https://devdongbaek.tistory.com/100

Django 로그인, 로그아웃 구현하기

devdongbaek.tistory.com

<form action="{% url 'login' %}" method="POST">
    {% csrf_token %}
    username : <input type="text" name='username'>
    password : <input type="text" name='password'>
    <br />
    <input type="submit" value='로그인'>
</form>

로그인 form

from django.shortcuts import redirect, render
from django.contrib import auth
from django.contrib.auth.models import User

# Create your views here.

def login(request):
    # POST 요청이 들어오면 로그인 처리를 해줌
    if request.method == 'POST':
        # 클라이언트가 입력한 값을 변수에 저장
        username = request.POST['username']
        password = request.POST['password']
        
        # auth.authenticate()은 사용자가 입력한 username과 password가 데이터에 저장되어 있는지 확인 후 
        # 저장되어 있으면 user 객체를 반환하고, 없다면 None을 반환하는 함수
        user = auth.authenticate(request, username=username, password=password)
        
        if user is not None:
            auth.login(request, user)
            return redirect('home')
        else:
            return render(request, 'home')
                
    # GET 요청이 들어오면 login form을 담고있는 login.html을 띄워주는 역할을 함
    else:
        return render(request, 'login.html')

로그인 함수

def logout(request):
    auth.logout(request)
    return redirect('home')

로그아웃 함수

LOGIN_REDIRECT_URL = "/"

로그인 성공시 이동할 주소를 settings.py에서 설정 가능

GET과 POST의 차이를 잘 이해하자

GET은 유저에게 페이지를 보여줄 때
POST는 유저가 입력한 값을 서버로 전송할 때

https://docs.djangoproject.com/en/4.0/ref/contrib/auth/

django.contrib.auth | Django documentation | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

익명 게시판

게시글 작성자가 익명으로 보이게 하는 것

    <div class="card-body">
        <div class="table-responsive">
            <table class="table table-bordered" id="dataTable" width="100%" cellspacing="0">
                <thead>
                    <tr>
                        <th width='70%'>글 제목</th>
                        <th>작성 날짜</th>
                        <th>작성자</th>
                    </tr>
                </thead>
                <tbody>
                    {% for post in posts %}
                    <tr>
                        <td><a href="#">{{ post.title }}</a></td>
                        <td>{{ post.date }}</td>
                        <td>익명</td>
                    </tr>
                    {% endfor %}
                </tbody>
            </table>
        </div>
    </div>

작성자를 표시 하지 않고 그냥 작성자라고 아예 명시함

글 제목을 누를 시 이동하게 하는 법

                <tbody>
                    {% for post in posts %}
                    <tr>
                        <td><a href="{% url 'detail' post.id %}">{{ post.title }}</a></td>
                        <td>{{ post.date }}</td>
                        <td>익명</td>
                    </tr>
                    {% endfor %}
                </tbody>

<tbody> 태그는 HTML 테이블에서 내용 콘텐츠(body content)들을 하나의 그룹으로 묶을 때 사용합니다.

<tbody> 요소는 테이블의 각 영역(header, body, footer)을 명시하기 위해 <thead>, <tfoot> 요소와 함께 사용됩니다.

브라우저는 이러한 요소들을 사용하여 테이블의 헤더나 푸터와는 독립적으로 테이블의 내용만 스크롤되게 할 수 있으며, 여러 페이지에 걸쳐 있는 큰 테이블을 인쇄할 때 각 페이지의 상단과 하단에 테이블의 헤더와 푸터가 모두 인쇄되도록 할 수도 있습니다.

<tbody> 요소는 <table> 요소의 자식 요소로써, 반드시 모든 <caption>, <colgroup>, <thead> 요소 다음에 위치해야 합니다. 또한, <tbody> 요소는 반드시 하나 이상의 <tr> 요소를 포함하고 있어야 합니다.

<thead>와 <tbody>, <tfoot> 요소는 기본적으로 웹 페이지의 레이아웃에 전혀 영향을 주지 않지만, 이 요소들의 스타일을 CSS를 사용하여 변경할 수는 있습니다.

글들을 표현할 때는 table을 이용하여 목록을 구성

https://getbootstrap.com/docs/4.1/content/tables/

Tables

Documentation and examples for opt-in styling of tables (given their prevalent use in JavaScript plugins) with Bootstrap.

getbootstrap.com

댓글 입력받은 값을 데이터에 저장하기

# 댓글 저장
def new_comment(request, pk):
    filled_form = CommentForm(request.POST)
    if filled_form.is_valid():
        filled_form.save(commit=False)
        filled_form.post = get_object_or_404(Post, pk=pk)
        filled_form.save()
    return redirect('detail', pk)

commit=False를 통해서 Comment의 외래키를 해당 포스트의 글 pk로 지정 후 최종 저장한다.

로그인 실패시 문구가 뜨게 하는 법

{% if form.errors %}
                    <p style="color:red;">아이디, 비밀번호가 일치하지 않습니다. 다시 시도해주세요.</p>
{% endif %}

클래스 뷰(CBV)를 사용해서 로그인, 로그아웃 구현

from django.contrib.auth.views import LoginView, LogoutView, logout_then_login


login = LoginView.as_view(template_name= "login.html")

#def logout(request):
    #return logout_then_login(request)

logout = LogoutView.as_view(next_page = "login")

Form들에 부트스트랩을 적용하기 위해서는 클래스를 적용해야 한다.

from django import forms
from .models import Post, Comment

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = '__all__'
    
    def __init__(self, *args, **kwargs):
        super(PostForm, self).__init__(*args, **kwargs)

        self.fields['title'].widget.attrs = {
            'class': 'form-control',
            'placeholder': "글 제목을 입력해주세요",
            'rows': 20
        }

        self.fields['body'].widget.attrs = {
            'class': 'form-control',
            'placeholder': "글 제목을 입력해주세요",
            'rows': 20,
            'cols' : 100
        }


class CommentForm(forms.ModelForm):
    class Meta:
        model = Comment
        fields = ['comment']

    def __init__(self, *args, **kwargs):
        super(CommentForm, self).__init__(*args, **kwargs)

        self.fields['comment'].widget.attrs = {
            'class': 'form-control',
            'placeholder': "댓글을 입력해주세요",
            'rows': 10
        }

widget.attrs은 widget에 클래스를 부여해주고, 아래 처럼 이 클래스를 통해 부트스트랩이나 css를 적용할 수 있습니다.

<input type="text" class="form-control bg-light border-0 small"
                                            placeholder="Search for..." aria-label="Search"
                                            aria-describedby="basic-addon2">

https://docs.djangoproject.com/en/4.0/ref/forms/widgets/

Widgets | Django documentation | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

https://ssungkang.tistory.com/entry/Django-widget-1-widget%EC%9D%98-%EC%9B%90%EB%A6%AC%EC%99%80-widget-%EB%A7%8C%EB%93%A4%EC%96%B4%EB%B3%B4%EA%B8%B0-%EC%8B%A4%EC%8B%9C%EA%B0%84-%EA%B8%80%EC%9E%90%EC%88%98-%ED%91%9C%EC%8B%9C-widget

[Django] widget (1) widget의 원리와 widget 만들어보기 - 실시간 글자수 표시 widget

input 태그는 type 속성에 따라 여러 모습을 보여줍니다. text 일 때는 글을 입력할 수 있도록, date 일 때는 날짜를 지정할 수 있도록, password 일 때는 비밀번호를 입력할 수 있도록 하는 등 다양한 type

ssungkang.tistory.com

자유 게시판 구현하기

from django.contrib.auth.models import User

# 자유 게시물 모델
class FreePost(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    date = models.DateTimeField(auto_now_add=True)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    
    def __str__(self):
        return self.title

User를 외래키로 삼아서 작성자를 저장

def freepostcreate(request):
    if request.method == 'POST' or request.method == 'FILES':
        # BlogForm 객체를 만들고 인자로 입력한 값들을 넘김
        form = FreePostForm(request.POST, request.FILES) 
        # 유효성 검사에 통과했다면
        if form.is_valid():           
            # DB에 최종 저장
            finished_form = form.save(commit=False)
            finished_form.author = request.user
            finished_form.save()
            return redirect('freehome')
        
    # 입력내용을 받을 수 있는 html 전달
    else:
        form = FreePostForm()
    
    # render()의 세번째 인자로 views.py의 데이터를 딕셔너리 자료형으로 html에 넘겨줄 수 있다.
    return render(request, 'free_post_form.html', {'form':form})

현재 유저를 글 작성자로 지정한다.

            finished_form.author = request.user

회원가입 구현하기

https://devdongbaek.tistory.com/92

Django 회원가입, 로그인 구현하기!!!

devdongbaek.tistory.com

from django.shortcuts import render, redirect
from django.contrib.auth.views import LoginView, LogoutView, logout_then_login
from django.contrib import auth
from django.contrib.auth.models import User

def signup(request):
    if request.method == "POST":
        # 만약 첫 비밀번호와 나중 비밀번호가 같다면
        if request.POST['password'] == request.POST['repeat']:
            # 회원가입
            new_user = User.objects.create_user(username=request.POST['username'], password=request.POST['password'])
            # 로그인
            auth.login(request, new_user)
            # 홈 리다이렉션
            return redirect('home')
    
    # 같지 않다면 다시 회원가입 페이지로       
    return render(request, 'register.html')

                            <form class="user" method="POST">
                                {% csrf_token %}
                                <div class="form-group row">
                                </div>
                                <div class="form-group">
                                    <input type="text" name="username" class="form-control form-control-user" id="exampleInputEmail"
                                        placeholder="Enter Your ID...">
                                </div>
                                <div class="form-group row">
                                    <div class="col-sm-6 mb-3 mb-sm-0">
                                        <input type="password" name="password" class="form-control form-control-user"
                                            id="exampleInputPassword" placeholder="Password">
                                    </div>
                                    <div class="col-sm-6">
                                        <input type="password" name="repeat" class="form-control form-control-user"
                                            id="exampleRepeatPassword" placeholder="Repeat Password">
                                    </div>
                                </div>
                                <br/>
                                <br/>
                                <br/>
                                <input type="submit" class="btn btn-success btn-user btn-block" value="회원가입">
                                <hr>
                            </form>
                            <div class="text-center">
                                <a class="small" href="{% url 'login' %}">Already have an account? Login!</a>
                            </div>

Pagination

https://ssungkang.tistory.com/entry/Django-11-Pagination-%EC%9D%84-%EC%95%8C%EC%95%84%EB%B3%B4%EC%9E%90

[Django] 11. Pagination 을 알아보자

안녕하세요 강민성입니다. 이번 시간에도 마찬가지로 blog project를 이어서 진행해보도록 하겠습니다. 글을 계속 추가할수록 글은 아래로 쌓이게 됩니다. 하지만 대부분의 웹사이트는 일정 수준

ssungkang.tistory.com

Pagination -> 객체들의 목록을 페이지 별로 나눠서 보여주도록 하는 것

from django.core.paginator import Paginator

def home(request):
    # 최신글 기준으로 order_by
    posts = Post.objects.filter().order_by('-date')
    # Paginator 함수의 첫 인자로는 페이징할 객체, 두번째 인자로는 몇 개씩 끉을 것인지
    paginator = Paginator(posts, 10)
    #  page에 해당되는 value를 가져오면 page의 번호를 리턴 받을 수 있습니다.
    pagenum = request.GET.get('page')
    # 해당 pagenum에 해당하는 posts 객체들을 저장
    posts = paginator.get_page(pagenum)
    return render(request, 'index.html', {'posts':posts} )

blog_list = Blog.objects.all()

그 전에도 사용한 적 있습니다. Blog 클래스의 모든 객체들을 blog_list에 담아두게 됩니다.

paginator = Paginator(blog_list, 3)

위에서 import한 Paginator입니다.

2개의 인자를 받는데 첫 번째로 페이지로 분할될 객체, 두 번째로 한 페이지에 담길 객체의 수를 받습니다.

page = request.GET.get('page')

request는 사용자가 보낸 총체적인 정보를 담고 있습니다.

어디서 어떤 페이지로 정보를 보내는지 등 말이죠.

GET은 request 방식 중 하나 입니다.

GET 방식으로 정보를 받아오는 데이터를 가르키게 됩니다.

get 은 딕셔너리 자료형에서 key값으로 value를 찾을 때 사용됩니다.

그 말인 즉슨, request.GET 으로 받아온 값은 딕셔너리 자료형 이라는 의미죠.

ex) http://127.0.0.1:8000/title=first&body=hello

{'title':first, "body":hello}

여기서 page에 해당되는 value를 가져오면 page의 번호를 리턴 받을 수 있습니다.

posts = paginator.get_page(page)

get_page 메소드는 페이지 번호를 받아 해당 페이지를 리턴하게 됩니다.

그 후 이 페이지를 다시 render를 통해 넘겨주게 됩니다.

https://velog.io/@kimkrh/Django-request.GET.get

[Django] request.GET.get()

request.get()과 request.GET.get()의 차이점

velog.io

-> page를 프론트엔드 단에 표시하는 방법

{% extends 'base.html' %}
{% load bootstrap4 %}
{% block content %}
<!-- Page Heading -->
<!-- DataTales Example -->
<div class="card shadow mb-4">
    <div class="card-header py-3">
        <h6 class="m-0 font-weight-bold text-success">익명게시판</h6>
    </div>
    <div class="card-body">
        <div class="table-responsive">
            <table class="table table-bordered" id="dataTable" width="100%" cellspacing="0">
                <thead>
                    <tr>
                        <th width='70%'>글 제목</th>
                        <th>작성 날짜</th>
                        <th>작성자</th>
                    </tr>
                </thead>
                <tbody>
                    {% for post in posts %}
                    <tr>
                        <td><a href="{% url 'detail' post.id %}">{{ post.title }}</a></td>
                        <td>{{ post.date }}</td>
                        <td>익명</td>
                    </tr>
                    {% endfor %}
                </tbody>
            </table>
        </div>
    </div>
</div>
{% if user.is_authenticated %}
    <a href="{% url 'postcreate' %}" class="btn btn-success btn-icon-split">
        <span class="icon text-white-50">
            <i class="fas fa-flag"></i>
        </span>
        <span class="text">글쓰기</span>
    </a>
{% endif %}

<!-- 페이지네이션 -->


{% bootstrap_pagination posts size="small" justify_content="center" %}


<a href="?page=1">첫 페이지</a>
{% if posts.has_previous %}
    <a href="?page={{ posts.previous_page_number }}">이전 페이지</a>
{% endif %}

<span>현재 페이지 : {{ posts.number }}</span>
<span>/</span>
<span>{{ posts.paginator.num_pages }}</span>

{% if posts.has_next %}
    <a href="?page={{ posts.next_page_number }}">다음 페이지</a>
    <a href="?page={{ posts.paginator.num_pages }}">마지막 페이지</a>
{% endif %}

{% endblock %}

외부 DB 연동하기

mariaDB를 Django와 연동하기

1. mariaDB 설치

! root 계정 비밀번호와 port번호가 3306인지 확인하기
mariaDB 설치시 자동으로 HeidiSQL이 설치되는데 이는 mariaDB안 테이블들을 쉽게 확인할 수 있는 SQL이다.

https://mariadb.com/kb/en/mariadb-server-10-6-8/

MariaDB Server 10.6.8

<div class="pdl-cta"> Thank you for downloading. Create your MariaDB account to receive download release notifications, product updates an...

mariadb.com

2. Django와 연동하기 위해서 mysqlclient를 설치해줘야함

pip install mysqlclient

https://victorydntmd.tistory.com/275

[Python3.6] mysqlclient 설치 에러 해결

윈도우 환경에서 python mysql을 사용하기 위해 pip install mysqlclient 으로 mysql을 설치하려고 하면, 아래와 같은 에러들이 발생하는 경우가 있습니다. 1. 이 메시지는 윈도우에서 Python module을 설..

victorydntmd.tistory.com

https://lemontia.tistory.com/756

[python-pip] mysqlclient 설치 중 에러날때(mysql.h)

pip3로 mysqlclient를 설치할때 다음의 에러가 발생할 수 있습니다. mysql.c _mysql.c(29): fatal error C1083: 포함 파일을 열 수 없습니다. 'mysql.h': No such file or directory error: command 'C:\\Program..

lemontia.tistory.com

3. settings.py에 DB 관련 설정

MYDATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mysql',
        'USER': 'root',
        'PASSWORD': '루트계정암호',
        'HOST': '127.0.0.1',
        'PORT': '3306'
    }
}

! settings.py의 DB PASSWORD와 SECRET_KEY는 절대 외부에 노출되어서는 안된다.

그래서 보통 my_settings.py라는 파일을 만들고 그곳에 DB PASSWORD와 SECRET_KEY를 저장하고 import한다.

from .my_settings import MYSECRET_KEY, MYDATABASES

SECRET_KEY = MYSECRET_KEY
DATABASES = MYDATABASES

소셜 로그인

https://django-allauth.readthedocs.io/en/latest/installation.html

Installation — django-allauth 0.43.0 documentation

Post-Installation In your Django root execute the command below to create your database tables: Now start your server, visit your admin pages (e.g. http://localhost:8000/admin/) and follow these steps: Add a Site for your domain, matching settings.SITE_ID

django-allauth.readthedocs.io

1. 패키지를 설치

$ pip install django-allauth

2. settings.py에 등록


INSTALLED_APPS = [
    ...
    # The following apps are required:
    'django.contrib.auth',
    'django.contrib.messages',
    'django.contrib.sites',

    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    # ... include the providers you want to enable:
    'allauth.socialaccount.providers.agave',
    'allauth.socialaccount.providers.amazon',
    'allauth.socialaccount.providers.amazon_cognito',
    'allauth.socialaccount.providers.angellist',
    'allauth.socialaccount.providers.apple',
    'allauth.socialaccount.providers.asana',
    'allauth.socialaccount.providers.auth0',
    'allauth.socialaccount.providers.authentiq',
    'allauth.socialaccount.providers.azure',
    'allauth.socialaccount.providers.baidu',
    'allauth.socialaccount.providers.basecamp',
    'allauth.socialaccount.providers.battlenet',
    'allauth.socialaccount.providers.bitbucket',
    'allauth.socialaccount.providers.bitbucket_oauth2',
    'allauth.socialaccount.providers.bitly',
    'allauth.socialaccount.providers.box',
    'allauth.socialaccount.providers.cern',
    'allauth.socialaccount.providers.cilogon',
    'allauth.socialaccount.providers.clever',
    'allauth.socialaccount.providers.coinbase',
    'allauth.socialaccount.providers.dataporten',
    'allauth.socialaccount.providers.daum',
    'allauth.socialaccount.providers.digitalocean',
    'allauth.socialaccount.providers.discord',
    'allauth.socialaccount.providers.disqus',
    'allauth.socialaccount.providers.douban',
    'allauth.socialaccount.providers.doximity',
    'allauth.socialaccount.providers.draugiem',
    'allauth.socialaccount.providers.drip',
    'allauth.socialaccount.providers.dropbox',
    'allauth.socialaccount.providers.dwolla',
    'allauth.socialaccount.providers.edmodo',
    'allauth.socialaccount.providers.edx',
    'allauth.socialaccount.providers.eventbrite',
    'allauth.socialaccount.providers.eveonline',
    'allauth.socialaccount.providers.evernote',
    'allauth.socialaccount.providers.exist',
    'allauth.socialaccount.providers.facebook',
    'allauth.socialaccount.providers.feedly',
    'allauth.socialaccount.providers.figma',
    'allauth.socialaccount.providers.fivehundredpx',
    'allauth.socialaccount.providers.flickr',
    'allauth.socialaccount.providers.foursquare',
    'allauth.socialaccount.providers.frontier',
    'allauth.socialaccount.providers.fxa',
    'allauth.socialaccount.providers.gitea',
    'allauth.socialaccount.providers.github',
    'allauth.socialaccount.providers.gitlab',
    'allauth.socialaccount.providers.globus',
    'allauth.socialaccount.providers.google',
    'allauth.socialaccount.providers.gumroad',
    'allauth.socialaccount.providers.hubic',
    'allauth.socialaccount.providers.instagram',
    'allauth.socialaccount.providers.jupyterhub',
    'allauth.socialaccount.providers.kakao',
    'allauth.socialaccount.providers.keycloak',
    'allauth.socialaccount.providers.lemonldap',
    'allauth.socialaccount.providers.line',
    'allauth.socialaccount.providers.linkedin',
    'allauth.socialaccount.providers.linkedin_oauth2',
    'allauth.socialaccount.providers.mailchimp',
    'allauth.socialaccount.providers.mailru',
    'allauth.socialaccount.providers.mediawiki',
    'allauth.socialaccount.providers.meetup',
    'allauth.socialaccount.providers.microsoft',
    'allauth.socialaccount.providers.naver',
    'allauth.socialaccount.providers.nextcloud',
    'allauth.socialaccount.providers.odnoklassniki',
    'allauth.socialaccount.providers.openid',
    'allauth.socialaccount.providers.openstreetmap',
    'allauth.socialaccount.providers.orcid',
    'allauth.socialaccount.providers.patreon',
    'allauth.socialaccount.providers.paypal',
    'allauth.socialaccount.providers.persona',
    'allauth.socialaccount.providers.pinterest',
    'allauth.socialaccount.providers.pocket',
    'allauth.socialaccount.providers.quickbooks',
    'allauth.socialaccount.providers.reddit',
    'allauth.socialaccount.providers.robinhood',
    'allauth.socialaccount.providers.salesforce',
    'allauth.socialaccount.providers.sharefile',
    'allauth.socialaccount.providers.shopify',
    'allauth.socialaccount.providers.slack',
    'allauth.socialaccount.providers.snapchat',
    'allauth.socialaccount.providers.soundcloud',
    'allauth.socialaccount.providers.spotify',
    'allauth.socialaccount.providers.stackexchange',
    'allauth.socialaccount.providers.steam',
    'allauth.socialaccount.providers.stocktwits',
    'allauth.socialaccount.providers.strava',
    'allauth.socialaccount.providers.stripe',
    'allauth.socialaccount.providers.telegram',
    'allauth.socialaccount.providers.trainingpeaks',
    'allauth.socialaccount.providers.trello',
    'allauth.socialaccount.providers.tumblr',
    'allauth.socialaccount.providers.twentythreeandme',
    'allauth.socialaccount.providers.twitch',
    'allauth.socialaccount.providers.twitter',
    'allauth.socialaccount.providers.untappd',
    'allauth.socialaccount.providers.vimeo',
    'allauth.socialaccount.providers.vimeo_oauth2',
    'allauth.socialaccount.providers.vk',
    'allauth.socialaccount.providers.weibo',
    'allauth.socialaccount.providers.weixin',
    'allauth.socialaccount.providers.windowslive',
    'allauth.socialaccount.providers.xing',
    'allauth.socialaccount.providers.yahoo',
    'allauth.socialaccount.providers.yandex',
    'allauth.socialaccount.providers.ynab',
    'allauth.socialaccount.providers.zoho',
    'allauth.socialaccount.providers.zoom',
    'allauth.socialaccount.providers.okta',
    'allauth.socialaccount.providers.feishu',
    ...
]

SITE_ID = 1

3. urls.py에 등록

urlpatterns = [
    ...
    path('accounts/', include('allauth.urls')),
    ...
]

4. migrate 진행

5. admin단 수정

https://console.cloud.google.com/welcome?project=northern-center-355407

Google 클라우드 플랫폼

로그인 Google 클라우드 플랫폼으로 이동

accounts.google.com

client id와 Secret Key는 구글 콘솔 사이트에서 입력받음

1. 새 프로젝트 생성하기

2. API 및 서비스에 들어간 후 사용자 인증 정보 만들기 -> OAuth 클라이언트 ID 만들기 -> 사용자 인증정보 만들기 -> OAuth 클라이언트 ID 만들기 -> 어플리케이션 유형(웹 어플리케이션), 승인된 자바스크립트 원본(http://127.0.0.1:8000), 승인된 리다이렉션(http://127.0.0.1:8000/accounts/google/login/callback/)

3. 클라이언트 아이디와 비밀번호를 admin에 이어서 작성

6. settngs.py 이어서 작성

# 어떤 수단을 통해서 로그인 할 것인지에 대해서
AUTHENTICATION_BACKENDS = [
   
    # Needed to login by username in Django admin, regardless of `allauth`
    # 기존 장고의 내장되어있는 인증 기능
    'django.contrib.auth.backends.ModelBackend',

    # `allauth` specific authentication methods, such as login by e-mail
    # 소셜 로그인 기능
    'allauth.account.auth_backends.AuthenticationBackend',
    
]

LOGIN_REDIRECT_URL = '/'

7.템플릿단 구현

{% load socialaccount %}

<a href="{% provider_login_url 'google' %}" class="btn btn-google btn-user btn-block">
                                        <i class="fab fa-google fa-fw"></i> 구글 계정으로 가입 </a>

api 연동하기

https://developers.naver.com/docs/serviceapi/search/blog/blog.md#%EB%B8%94%EB%A1%9C%EA%B7%B8

블로그 - Search API

블로그 NAVER Developers - 검색 API 블로그 검색 개발가이드 검색 > 블로그 네이버 블로그 검색 결과를 출력해주는 REST API입니다. 비로그인 오픈 API이므로 GET으로 호출할 때 HTTP Header에 애플리케이션

developers.naver.com

!api 문서를 보는게 매우 중요

1. API를 사용하기 위해서는 오픈 API 이용 신청을 하는게 중요 -> 클라이언트 ID와 클라이언트 Secret Key를 받기 위해서

2. API를 응답받을 URL을 지정 ex) https://openapi.naver.com/v1/search/movie.json

3. 요청 변수는 위 URL 뒤에 ?key='value' 에서 key이며 value를 가져온다.

4. 필수 요청 변수는 반드시 적어주어야 한다. ex)query

API 호출 예시

curl "https://openapi.naver.com/v1/search/movie.xml?query=%EC%A3%BC%EC%8B%9D&display=10&start=1&genre=1" \
    -H "X-Naver-Client-Id: {애플리케이션 등록 시 발급받은 client id 값}" \
    -H "X-Naver-Client-Secret: {애플리케이션 등록 시 발급받은 client secret 값}" -v

한글이 url에 표시될때는 %EC%로 표시된다.
&은 and를 의미한다.

API 요청 예시

> GET /v1/search/movie.xml?query=%EC%A3%BC%EC%8B%9D&display=10&start=1&genre=1 HTTP/1.1
> Host: openapi.naver.com
> User-Agent: curl/7.49.1
> Accept: */*
> X-Naver-Client-Id: {애플리케이션 등록 시 발급받은 client id 값}
> X-Naver-Client-Secret: {애플리케이션 등록 시 발급받은 client secret 값}

API 응답 예시

< HTTP/1.1 200 OK
< Server: nginx
< Date: Wed, 28 Sep 2016 07:40:17 GMT
< Content-Type: text/xml;charset=utf-8
< Transfer-Encoding: chunked
< Connection: keep-alive
< Keep-Alive: timeout=5
< Vary: Accept-Encoding
< X-Powered-By: Naver
< Cache-Control: no-cache, no-store, must-revalidate
< Pragma: no-cache
<
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
    <channel>
        <title>Naver Open API - movie ::'주식'</title>
        <link>http://search.naver.com</link>
        <description>Naver Search Result</description>
        <lastBuildDate>Wed, 28 Sep 2016 16:40:17 +0900</lastBuildDate>
        <total>2</total>
        <start>1</start>
        <display>2</display>
        <item>
            <title>주마등&lt;b&gt;주식&lt;/b&gt;회사</title>
            <link>http://openapi.naver.com/l?AAADWLQQvCIBzFP83f48h0zh08uK1B0S2IOm7mUEIts0F9+vQQPN77vQfv+dbxI2DXgyTQ9QV4B+2ATNSLMCk9gEjYjlkurFZXflp1rFRw/yXnbEspNk8vqypvPJBRhZsGMrSMY4ySwLSpN5RT3NSYIScO5nxhdzc18cjq0958w8LneKUy8fz6AdRxjD6YAAAA</link><image>http://imgmovie.naver.com/mdi/mit110/0968/96811_P01_142155.jpg</image>
            <subtitle>走馬&amp;amp;#28783;株式&amp;amp;#20250;社</subtitle>
            <pubDate>2012</pubDate>
            <director>미키 코이치로|</director>
            <actor>카시이 유우|쿠보타 마사타카|카지와라 히카리|치요 쇼타|요코야마 메구미|카시와바라 슈지|</actor>
            <userRating>4.50</userRating>
        </item>
        ...
    </channel>
</rss>

파이썬 API 호출 예제

# 네이버 검색 API예제는 블로그를 비롯 전문자료까지 호출방법이 동일하므로 blog검색만 대표로 예제를 올렸습니다.
# 네이버 검색 Open API 예제 - 블로그 검색
import os
import sys

# 특정 url에 request를 보낼 수 있도록 해주는 라이브러리
import urllib.request

# API 이용 신청을 통해 받은 id와 secret 입력
client_id = "YOUR_CLIENT_ID"
client_secret = "YOUR_CLIENT_SECRET"

# 검색할 단어를 입력받을 변수
# urllib.parse.quote()는 아스키코드 형식이 아닌 글자를 URL 인코딩 시켜줍니다.
encText = urllib.parse.quote("검색할 단어")

# 위에서 알아본 것처럼 query={value}에서 value에 위 encText 변수를 삽입
# encText라는 검색어를 담고있는 url 변수 작성
url = "https://openapi.naver.com/v1/search/blog?query=" + encText # json 결과
# url = "https://openapi.naver.com/v1/search/blog.xml?query=" + encText # xml 결과

# request.Request는 URL 요청의 추상화
request = urllib.request.Request(url)

# url을 요청할 때 보안을 위해 헤더에 추가적인 정보를 요청하는 API들이 있다.
request.add_header("X-Naver-Client-Id",client_id)
request.add_header("X-Naver-Client-Secret",client_secret)

# urlopen은 request를 보낼 인자를 받고, request를 보내 response를 반환한다.
response = urllib.request.urlopen(request)

# 응답 코드를 받는다.
rescode = response.getcode()

# 200(성공 코드)를 받는다면 response를 출력한다.
if(rescode==200):
    response_body = response.read()
    print(response_body.decode('utf-8'))
else:
    print("Error Code:" + rescode)

https://incomeplus.tistory.com/254

파이썬 urllib.request VS requests 차이점?

파이썬으로 웹사이트를 크롤링 할 때 가장 많이 사용되는 함수가 urllib.request와 requests다. 분명히 두 개함수가 차이가 있고, 필요한 상황에 맞춰 사용할 줄 알아야 할 것이다. 먼저 크롤링을 하기

incomeplus.tistory.com

https://developer.mozilla.org/ko/docs/Web/HTTP/Status

HTTP 상태 코드 - HTTP | MDN

HTTP 응답 상태 코드는 특정 HTTP 요청이 성공적으로 완료되었는지 알려줍니다. 응답은 5개의 그룹으로 나누어집니다: 정보를 제공하는 응답, 성공적인 응답, 리다이렉트, 클라이언트 에러, 그리고

developer.mozilla.org

response에 저장된 api 객체를 JSON 형식으로 저장하고 싶을 때

# 네이버 검색 API예제는 블로그를 비롯 전문자료까지 호출방법이 동일하므로 blog검색만 대표로 예제를 올렸습니다.
# 네이버 검색 Open API 예제 - 블로그 검색
import os
import sys

import json

# 특정 url에 request를 보낼 수 있도록 해주는 라이브러리
import urllib.request

# API 이용 신청을 통해 받은 id와 secret 입력
client_id = "YOUR_CLIENT_ID"
client_secret = "YOUR_CLIENT_SECRET"

# 검색할 단어를 입력받을 변수
# urllib.parse.quote()는 아스키코드 형식이 아닌 글자를 URL 인코딩 시켜줍니다.
encText = urllib.parse.quote("검색할 단어")

# 위에서 알아본 것처럼 query={value}에서 value에 위 encText 변수를 삽입
# encText라는 검색어를 담고있는 url 변수 작성
url = "https://openapi.naver.com/v1/search/blog?query=" + encText # json 결과
# url = "https://openapi.naver.com/v1/search/blog.xml?query=" + encText # xml 결과

# request.Request는 URL 요청의 추상화
request = urllib.request.Request(url)

# url을 요청할 때 보안을 위해 헤더에 추가적인 정보를 요청하는 API들이 있다.
request.add_header("X-Naver-Client-Id",client_id)
request.add_header("X-Naver-Client-Secret",client_secret)

# urlopen은 request를 보낼 인자를 받고, request를 보내 response를 반환한다.
response = urllib.request.urlopen(request)

# 응답 코드를 받는다.
rescode = response.getcode()

# 200(성공 코드)를 받는다면 response를 출력한다.
if(rescode==200):
    response_body = response.read()
    print(response_body.decode('utf-8'))
else:
    print("Error Code:" + rescode)

resjson = response_body.decode('utf-8')

with open('movie.json', 'w', encoading='UTF-8-sig') as file:
	file.write(json.dumps(resjson, ensure_ascii=False))

JSON 각 key에 접근하는 방법

pydata = json.loads(resdata)
data = pydata['items']

https://www.daleseo.com/python-json/

파이썬의 json 모듈로 JSON 데이터 다루기

Engineering Blog by Dale Seo

www.daleseo.com

검색 기능 구현하기

https://devdongbaek.tistory.com/57

동백 // QuerySet을 통한 간단 검색 구현

devdongbaek.tistory.com

https://ghqls0210.tistory.com/53

django / 검색 기능

이번에는 검색 기능을 만들어보겠습니다. 검색 기능 또한 직전 포스팅인 정렬과 같은 html에 만들면 좋지만 그러면 강제적으로 만들어 놓은 url을 수정해야되서 새로 url을 만들어서 하겠습니다. u

ghqls0210.tistory.com

https://velog.io/@mongle/Django-Web-Project-%EA%B0%9C%EB%B0%9C%EC%9D%BC%EC%A7%804-%EA%B2%80%EC%83%89-%EA%B8%B0%EB%8A%A5-%EC%B6%94%EA%B0%80

Django Web Project 개발일지4) 검색 기능 추가

djangoWeb searh 기능 추가

velog.io

https://devdongbaek.tistory.com/91

Django 빌트인 CBV를 통한 Form 처리

devdongbaek.tistory.com

formview는 form을 보여주는 로직의 view

https://docs.djangoproject.com/en/3.0/ref/class-based-views/generic-editing/#django.views.generic.edit.FormView

Generic editing views | Django documentation | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

urls.py

path('search/', views.search.as_view(), name='search'),

forms.py

from django import forms

class SearchForm(forms.Form):
	search = forms.CharField(label='검색할 단어를 입력하세요', max_length=100)

views.py

from .forms import SearchForm

class search(Formview):
	form_class = SearchForm
    templates_name = 'blog/post_search.html'
	
    # form 입력이 성공했을 때
    def form_valid(self, form):
    	# form field 이름과 동일해야 함
    	searchWord = form.cleaned_data['search']
        post_list = Post.objects.filter(Q(title__icontains=searchWord) | Q(description__icontains=searchWord) | Q(content__icontains=searchWord)).distinct()
		
        # 딕셔너리 형식으로 값 저장
        """
        form = context.form
        searchWord = context.search_term
        post_list = context.object_list
        
        """
        context = {}
        context['form'] = form
        context['search_term'] = searchWord
        context['object_list'] = post_list

        return render(self.request, self.template_name, context)

. context라는 딕셔너리를 통해 템플릿에 인자를 전달한다.

templates

{% extends "base.html" %}

{% block title %}post_search.html{% endblock %}

{% block content %}
<h1>Blog Search</h1>
<br>

<form action="." method="post"> {% csrf_token %}
    {{ form.as_table }} <!-- form을 테이블 형식으로 표시, 여기서 form은 views에서 넘겨준 PostSearchForm 객체임-->
    <input type="submit" value="Submit" class="btn btn-primary btn-sm">
</form>

<br/><br/>

{% if object_list %}
    {% for post in object_list %}
        <h2><a href='{{ post.get_absolute_url }}'>{{ post.title }}</a></h2>
        {{ post.modify_date|date:"N d, Y" }}
        <p>{{ post.description }}</p>
    {% endfor %}
{% elif search_term %}<!-- 검색란이 공란인지 확인-->
    <b><i>Search Word({{ search_term }}) Not Found</i></b>
{% endif %}
{% endblock %}

https://velog.io/@jxxwon/Django-Q-%EA%B0%9D%EC%B2%B4

Django Q 객체

장고 Q객체

velog.io

CBV

https://wikidocs.net/9623

02) 클래스형 뷰 (CBV)

[TOC] # 클래스형 뷰 (CBV, Class-Based View) 클래스형 뷰는 상속과 믹스인 기능을 이용하여 코드 재사용하고 뷰를 체계적으로 구성할 수 있다. ## ...

wikidocs.net

17478번: 재귀함수가 뭔가요?

개발자Dongbaek — Tue, 17 May 2022 17:33:39 +0900

재귀함수가 뭔가요? 성공

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

256 MB

17549

6861

5613

37.980%

문제

평소에 질문을 잘 받아주기로 유명한 중앙대학교의 JH 교수님은 학생들로부터 재귀함수가 무엇인지에 대하여 많은 질문을 받아왔다.

매번 질문을 잘 받아주셨던 JH 교수님이지만 그는 중앙대학교가 자신과 맞는가에 대한 고민을 항상 해왔다.

중앙대학교와 자신의 길이 맞지 않다고 생각한 JH 교수님은 결국 중앙대학교를 떠나기로 결정하였다.

떠나기 전까지도 제자들을 생각하셨던 JH 교수님은 재귀함수가 무엇인지 물어보는 학생들을 위한 작은 선물로 자동 응답 챗봇을 준비하기로 했다.

JH 교수님이 만들 챗봇의 응답을 출력하는 프로그램을 만들어보자.

입력

교수님이 출력을 원하는 재귀 횟수 N(1 ≤ N ≤ 50)이 주어진다.

출력

출력 예시를 보고 재귀 횟수에 따른 챗봇의 응답을 출력한다.

재귀 함수를 사용하지 않은 내 정답 코드

under_bar = "____"

def factorial(i):
    print((i * under_bar) + '''"재귀함수가 뭔가요?"''')
    print((i * under_bar) + '''"잘 들어보게. 옛날옛날 한 산 꼭대기에 이세상 모든 지식을 통달한 선인이 있었어.\n''' + (i * under_bar) + "마을 사람들은 모두 그 선인에게 수많은 질문을 했고, 모두 지혜롭게 대답해 주었지.\n" + (i * under_bar) + '''그의 답은 대부분 옳았다고 하네. 그런데 어느 날, 그 선인에게 한 선비가 찾아와서 물었어."''')
    
    
n = int(input())

print("어느 한 컴퓨터공학과 학생이 유명한 교수님을 찾아가 물었다.")

for i in range(n): # 0, 1, 2
    factorial(i)

    
for i in range(n, -1, -1):
    if i == n:
        print((i*under_bar)+ '''"재귀함수가 뭔가요?"''')
        print((i*under_bar)+ '''"재귀함수는 자기 자신을 호출하는 함수라네"''')
    print((i*under_bar)+ "라고 답변하였지.")

재귀 함수를 사용한 내 정답 코드

under_bar = "____"

ans_list = []

def factorial(n):
    ans_list.append((n * under_bar) + '''그의 답은 대부분 옳았다고 하네. 그런데 어느 날, 그 선인에게 한 선비가 찾아와서 물었어."''')
    ans_list.append((n * under_bar) + "마을 사람들은 모두 그 선인에게 수많은 질문을 했고, 모두 지혜롭게 대답해 주었지.")
    ans_list.append((n * under_bar) + '''"잘 들어보게. 옛날옛날 한 산 꼭대기에 이세상 모든 지식을 통달한 선인이 있었어.''' )
    ans_list.append((n * under_bar) + '''"재귀함수가 뭔가요?"''')
    
    if n > 0:
        factorial(n - 1)
    else:
        return 1
    

n = int(input())

print("어느 한 컴퓨터공학과 학생이 유명한 교수님을 찾아가 물었다.")

# 0, 1, 2
factorial(n-1)

ans_list.reverse()

for i in range(len(ans_list)):
    print(ans_list[i])


for i in range(n, -1 ,-1):
    if i == n:
        print((i*under_bar)+ '''"재귀함수가 뭔가요?"''')
        print((i*under_bar)+ '''"재귀함수는 자기 자신을 호출하는 함수라네"''')
    print((i*under_bar)+ "라고 답변하였지.")

백준 파이썬 3009: 네 번째 점

개발자Dongbaek — Sun, 1 May 2022 19:44:14 +0900

네 번째 점 성공다국어

한국어

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

128 MB

31100

22474

20247

73.260%

문제

세 점이 주어졌을 때, 축에 평행한 직사각형을 만들기 위해서 필요한 네 번째 점을 찾는 프로그램을 작성하시오.

입력

세 점의 좌표가 한 줄에 하나씩 주어진다. 좌표는 1보다 크거나 같고, 1000보다 작거나 같은 정수이다.

출력

직사각형의 네 번째 점의 좌표를 출력한다.

내 정답 코드

x = []
y = []

# x와 y 좌표들을 입력받습니다!
for i in range(3):
    a, b = map(int, input().split())
    x.append(a)
    y.append(b)
 
# x와 y 좌표들중 중복된 것이 있다면 변수에 저장해줍니다!
for j in range(3):
    if x.count(x[j]) > 1:
        xrepeated_num = x[j]

    if y.count(y[j]) > 1:
        yrepeated_num = y[j]
        

# x와 y중 중복된 것들을 제거해줍니다!
while xrepeated_num in x:
    x.remove(xrepeated_num)

while yrepeated_num in y:
    y.remove(yrepeated_num)

print("{0} {1}".format(x[0], y[0]))

_ 평행한 직사각형의 특징을 이용하여 해당 문제를 해결하였습니다. 입력 예시를 통해서 위 코드를 설명해드리겠습니다!

입력 예시는 아래와 같습니다!

1번째 x: 5, y: 5

2번째 x: 5, y: 7

3번째 x: 7, y: 5

위를 좌표 형식으로 생각한다면 x의 점들은 5와 7 위에 위치할 것이고, y의 점또한 5와 7에 위치할 것입니다.

이 때 중요한 것은 평행한 직사각형의 좌표이기에 이미 두개가 표시된(=중복된) 좌표는 새로운 좌표가 올 수 없기에 제거해주면 x는 7, y는 7이 남아 답이 됩니다!!!

백준 파이썬 9020: 골드바흐의 추측

개발자Dongbaek — Tue, 29 Mar 2022 11:21:49 +0900

골드바흐의 추측 성공다국어

한국어

시간 제한메모리 제한제출정답맞힌 사람정답 비율

2 초

256 MB

53440

22452

17139

40.620%

문제

1보다 큰 자연수 중에서 1과 자기 자신을 제외한 약수가 없는 자연수를 소수라고 한다. 예를 들어, 5는 1과 5를 제외한 약수가 없기 때문에 소수이다. 하지만, 6은 6 = 2 × 3 이기 때문에 소수가 아니다.

골드바흐의 추측은 유명한 정수론의 미해결 문제로, 2보다 큰 모든 짝수는 두 소수의 합으로 나타낼 수 있다는 것이다. 이러한 수를 골드바흐 수라고 한다. 또, 짝수를 두 소수의 합으로 나타내는 표현을 그 수의 골드바흐 파티션이라고 한다. 예를 들면, 4 = 2 + 2, 6 = 3 + 3, 8 = 3 + 5, 10 = 5 + 5, 12 = 5 + 7, 14 = 3 + 11, 14 = 7 + 7이다. 10000보다 작거나 같은 모든 짝수 n에 대한 골드바흐 파티션은 존재한다.

2보다 큰 짝수 n이 주어졌을 때, n의 골드바흐 파티션을 출력하는 프로그램을 작성하시오. 만약 가능한 n의 골드바흐 파티션이 여러 가지인 경우에는 두 소수의 차이가 가장 작은 것을 출력한다.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고 짝수 n이 주어진다.

출력

각 테스트 케이스에 대해서 주어진 n의 골드바흐 파티션을 출력한다. 출력하는 소수는 작은 것부터 먼저 출력하며, 공백으로 구분한다.

제한

4 ≤ n ≤ 10,000

내 정답 코드

# 테스트 케이스 총 범위
num = int(input())

n = 10000 


# 에라토스테네스의 체
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
    if a[i]:
        primes.append(i)
        for j in range(2*i, n+1, i):
            a[j] = False



for i in range(num):
    ans1 = 0
    ans2 = 0
    even = int(input())

    even_first = even // 2

    ans1 = even_first
    ans2 = even_first
    
    if ans1 not in primes and ans2 not in primes:
        while True:
            ans1 -= 1
            ans2 += 1
            
            if ans1 in primes and ans2 in primes:
                break
        
    print("{0} {1}".format(ans1, ans2))

_ 에라토스테네스의 체와 소수 문제를 풀어보셨던 분들은 아마 비교적 쉽게 푸실 수 있는 문제였을 것이라 생각이 듭니다. 먼저 위 코드를 Devide 하여서 자세히 살펴보겠습니다!

# 에라토스테네스의 체
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
    if a[i]:
        primes.append(i)
        for j in range(2*i, n+1, i):
            a[j] = False

_ 위 코드들은 에라토스테네스의 체를 이용해 소수를 구하는 코드입니다. 소수들은 primes 리스트에 저장되어 있습니다.

for i in range(num):
    ans1 = 0
    ans2 = 0
    even = int(input())

    even_first = even // 2

    ans1 = even_first
    ans2 = even_first
    
    if ans1 not in primes and ans2 not in primes:
        while True:
            ans1 -= 1
            ans2 += 1
            
            if ans1 in primes and ans2 in primes:
                break
        
    print("{0} {1}".format(ans1, ans2))

_ 위의 반복문을 Devide 해봅시다!

for i in range(num):
    ans1 = 0
    ans2 = 0
    even = int(input())

    even_first = even // 2

    ans1 = even_first
    ans2 = even_first

_ ans1과 ans2는 주어진 짝수(even)의 골드 파티션을 담을 변수들이며, ans1이 더 작은 소수에 속합니다.

_ 짝수(even)을 2로 나눈 값을 각 ans1과 ans2에 저장합니다.

    if ans1 not in primes and ans2 not in primes:
        while True:
            ans1 -= 1
            ans2 += 1
            
            if ans1 in primes and ans2 in primes:
                break
        
    print("{0} {1}".format(ans1, ans2))

_ 만약 짝수(even)을 2로 나눈 값이 primes 리스트에 속한다면, 즉 소수에 속한다면 그 값을 ans1과 ans2에 바로 저장해줍니다.

ex) 짝수(even)이 10이고 2로 나눈 값은 5이고, 소수에 속하기에 ans1과 ans2에 각 5의 값을 저장해줍니다.

_ 만약 소수에 속하지 않았다면 속하게 될 때 까지 ans1이 더 작은 값이기에 2로 나눈 값에서 1을 빼주고, ans2는 2로 나눈 값에서 1을 더해줍니다.

ex) 짝수(even)이 8이고 2로 나눈 값은 4

ans1 = 4, ans 2 = 4

-> ans1이 더 작은 값이기에 2로 나눈 값에서 1을 빼주고, ans2는 2로 나눈 값에서 1을 더해줍니다.

ans1 = 3, ans2 = 5

이런 식으로 답이 도출됩니다!!

백준 파이썬 4948: 베르트랑 공준

개발자Dongbaek — Sat, 26 Mar 2022 14:58:08 +0900

베르트랑 공준 성공다국어

한국어

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

256 MB

61963

24574

19945

39.874%

문제

베르트랑 공준은 임의의 자연수 n에 대하여, n보다 크고, 2n보다 작거나 같은 소수는 적어도 하나 존재한다는 내용을 담고 있다.

이 명제는 조제프 베르트랑이 1845년에 추측했고, 파프누티 체비쇼프가 1850년에 증명했다.

예를 들어, 10보다 크고, 20보다 작거나 같은 소수는 4개가 있다. (11, 13, 17, 19) 또, 14보다 크고, 28보다 작거나 같은 소수는 3개가 있다. (17,19, 23)

자연수 n이 주어졌을 때, n보다 크고, 2n보다 작거나 같은 소수의 개수를 구하는 프로그램을 작성하시오.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 케이스는 n을 포함하는 한 줄로 이루어져 있다.

입력의 마지막에는 0이 주어진다.

출력

각 테스트 케이스에 대해서, n보다 크고, 2n보다 작거나 같은 소수의 개수를 출력한다.

시간 초과가 났던 내 처음 코드

"""
    
    시간 초과

"""

# 테스트 케이스 총 범위
n=246912

# 에라토스테네스의 체
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
    if a[i]:
        primes.append(i)
        for j in range(2*i, n+1, i):
            a[j] = False

ans_cnt = []


while True:
    num = int(input())
    
    # 0을 입력받으면 종료    
    if num == 0:
        for i in ans_cnt:
            print(i)
        break
    
    # cnt들을 모아둔 리스트
    cnt = 0
    
    # 만약 범위내에 소수가 있으면 cnt에 1을 더해라
    for i in range(num+1, 2*num+1):
        if i in primes:
            cnt += 1
        
    # ans_cnt에 cnt를 추가해줌.
    ans_cnt.append(cnt)

_ 맨 처음 시간초과가 날 것 같긴했다.. 그 이유는 중복된 반복문들이 너무 많았다. 그래서 반복문을 함수에 넣어주기로 하였다.

내 정답 코드

# 테스트 케이스 총 범위
n=123456

# 에라토스테네스의 체
def prime_list(n):
    if n == 1:
        return False
    for i in range(2,int(n**0.5)+1):
        if n%i == 0:
            return False
    return True		

primes_list = list(range(2,246912))
ans_list = []

for i in primes_list:
    # 만약 소수에 해당하면 prime_list 함수에서 true를 반환 받을 것입니다.
    if prime_list(i):
        # true를 반환 받는다면 ans_list에 해당 원소(i)를 추가해줍니다.
        ans_list.append(i)
        
        
while True:
    
    cnt = 0

    num = int(input())

    # 0을 입력받으면 종료    
    if num == 0:
        break
    
    for i in ans_list:
        if num < i < 2*num+1:
            cnt += 1
            
    print(cnt)

_ 소수를 구하는 공식 에라토스테네스의 체를 아예 함수로 만들어주고, 모든 원소에 소수, 소수가 아닌 값인 True, False를 넣어주는 게 아닌 소수인 값만 ans_list에 저장함으로 불필요한 반복문 사용을 줄여주었다.

Django JSON 직렬화

개발자Dongbaek — Tue, 22 Mar 2022 16:02:34 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django JSON 직렬화(Serialization)

직렬화(serialization)

_모든 프로그래밍 언어의 통신에서 데이터는 필히 문자열로 표현되어야만 합니다.

송신자(백엔드) : 객체를 문자열로 변환하여, 데이터 전송 -> 직렬화
수신자(프론트엔드) : 수신한 문자열을 다시 객체로 변환하여, 활용 -> 비직렬화

_각 언어에서 모두 지원하는 직렬화 포맷 (JSON, XML 등)이 있고, 특정 언어에서만 지원하는 직렬화 포맷이 있습니다.

ex) 파이썬의 Pickle

JSON 변환

데이터는 같지만, 응답 형식이 다를 수는 있습니다.

_보통의 웹에서는 GET 요청에 대해 HTML 포맷으로 응답하고, POST 요청을 application/x-www-form-urlencoded 인코딩으로 요청하고, HTML 포맷으로 응답합니다.

_요즘의 API 서버에서는 대부분 JSON 인코딩으로 요청 / 응답합니다.

JSON 포맷과 PICKLE 포맷

JSON 포맷

다른 언어 / 플랫폼과 통신할 때 주로 사용
표준 라이브러리 json 제공 // 파이썬 기본 타입에 대해서는 지원을 하지만, Django나 커스텀 타입은 지원을 제공하지않음.
pickle에 비해서 직렬화를 지원하는 데이터 타입의 수가 적지만, 커스텀 Rule도 지정 가능

https://www.w3schools.com/python/python_json.asp

Python JSON

W3Schools offers free online tutorials, references and exercises in all the major languages of the web. Covering popular subjects like HTML, CSS, JavaScript, Python, SQL, Java, and many, many more.

www.w3schools.com

Pickle 포맷

파이썬 전용 포맷으로서 파이썬 시스템끼리만 통신할 때 사용 가능
표준 라이브러리 pickle 제공 -> json 라이브러리가 유사한 사용 방법
주의) 파이썬 버전 특성을 타는 경우가 있습니다

https://wayhome25.github.io/cs/2017/04/04/cs-04/

강의노트 04. 파이썬 pickle 모듈 · 초보몽키의 개발공부로그

패스트캠퍼스 컴퓨터공학 입문 수업을 듣고 중요한 내용을 정리했습니다. 개인공부 후 자료를 남기기 위한 목적임으로 내용 상에 오류가 있을 수 있습니다.

wayhome25.github.io

_ json / pickle 모두 파이썬 기본 라이브러리로 제공이 됩니다.

그러나 장고 타입 (Model / QuerySet 등)에 대해서는 직렬화 Rule이 없습니다. -> 오류 발생

_ 그러면 어떻게 해결 할 수 있을까요? -> 직접 변환하는 방법이 있습니다.

QuerySet을 JSON 형식으로 직접 바꿔준 다음 json.dumps를 통해 json으로 써줍니다.

data = [
    {'id': post.id, 'title':post.title, 'content': post.content}
    for post in Post.objects.all()
]
    
json.dumps(data, ensure_ascii=False).encode('utf8') # ensure_ascii에 False값을 주면, json.dumps()값을 UTF-8로 수동으로 인코딩할 수 있다.

_DjangoJSONEncoder를 통해 아래 타입들에 대한 Rule을 추가로 구현할 수 있습니다.

datetime.datetime, datetime.date, datetime.time, datetime.delta
decimal.Decimal, uuid.UUID, Promise

import json
from django.core.serializers.json import DjangoJSONEncoder

_ 그러나 매번 직접 변환하기는 너무 번거로우니 -> 직접 변환 Rule을 지정하거나 DRF의 JSONRender, DRF의 serializers.py를 이용하는 방법들이 있습니다. -> 그러나 이러한 방법들을 Model에 대한 변환 Rule은 지원하지 않습니다 ㅠㅠ

ModelSerializer를 통한 JSON 직렬화

_Serializer / ModelSerializer은 Form / ModelForm과 유사합니다.

-> 역할 면에서 Serializer은 POST 요청만 처리하는 Form

둘의 공통점
- 폼 필드 지정 혹은 모델로부터 읽어오기.
- 입력된 데이터에 대한 유효성 검사를 통해 저장합니다.
둘의 차이점
- Form / ModelForm : Form태그가 포함된 HTML을 생성합니다.
- Serializer / ModelSerializer : Form 데이터가 포함된 JSON 문자열을 생성합니다.

_ModelSerializer

from rest_framework.serializers import ModelSerializer

# Post모델에 대한 ModelSerializer 정의
class PostSerializer(ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

post = Post.objects.first() # Post 타입

serializer = PostSerializer(post)
serializer.data # -> ReturnDict 타입

https://www.django-rest-framework.org/api-guide/serializers/

Serializers - Django REST framework

www.django-rest-framework.org

_ Model 객체나 쿼리셋에 대해 ReturnDict type으로 변환 할 수 있습니다.

from .serializers import PostSerializer
from .models import Post

# 한개의 모델만 넘기기
serializer = PostSerializer(Post.objects.first())
serializer.data # {'id': 1, 'message': '첫번째 포스팅' ... }

# 쿼리셋을 넘기기
serializer = PostSerializer(Post.objects.all(), many=True)
serializer.data # [OrderDict([('id', 1), ...)]), OrderDict([('id': 2), ...)]) ...]

_ Model 객체에 대해서는 필히 many=False(디폴트)를 지정해주어야 하고,

쿼리셋 객체에 대해서는 필히 many=True를 지정해주어야 합니다.

-> 지정이 맞지 않으면 변환 에러가 발생하게 됩니다.

View에서의 JSON 응답

모든 View는 HttpResponse 타입의 응답을 해야 하고, 일반적으로 다음 2가지 방법을 사용합니다.

직접 json.dumps를 통해 직렬화된 문자열을 획득하여, HttpResponse를 통해 응답합니다.
1번을 정리하여 JsonResponse를 지원합니다.

DRF를 통한 JSON 응답

DRF Response를 활용합니다.

qs = Post.objects.all()

serializer = PostModelSerializer(qs, many=True)

from rest_framework.response import Response

response = Response(serializer.data) # Content-type : text/html이 디폴트 지정

_ Response에서는 "JSON 직렬화" 가 Lazy하게 동작합니다. 실제 응답 생성시에 .rendered_content 속성에 접근하며, 이 때 변환이 이루어집니다.

Response와 APIView

_ DRF의 모든 뷰는 APIView를 상속 받습니다. APIView를 통해서 Response에 다양한 속성이 지정됩니다.

from rest_framework.views import APIView

renderer_cls = APIView.renderer_classes[0]
renderer_obj = renderer_cls()
response.accepted_renderer = renderer_obj # JSON 변환을 위한 JSONRenderer 인스턴스

response.accepted_media_type = renderer_obj.media_type # 'application/json'
response.renderer_context = {'view': None, 'args': (), 'kwargs': {}, 'request': None}

response # <Response status_code=200, "application/json">

실제 DRF Serializer 사용

#views.py

from rest_framework import generics

class PostListAPIView(generics.ListAPIView): # 만약 list, create, detail, update, delete등을 모두 사용하려면 ViewSet을 이용
    queryset = Post.objects.all()
    serializer_class = PostSerializer

post_list = PostListAPIView.as_view()

#urls.py

urlpatterns = [
    path('public/', views.PostListAPIView.as_view()),
]

포스팅 조회 응답에 username 응답을 하려면?

_ author = FK(User) 필드가 있을 때, Serializer에서는 FK 키값으로 응답

serializer.ReadOnlyField를 통해서 FK의 필드값을 읽어 올 수 있습니다.

#models.py

from django.conf import settings
from django.db import models

# Create your models here.

class Post(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    message = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

#serializers.py

from rest_framework import serializers
from .models import Post
class PostSerializer(serializers.ModelSerializer):
    username = serializers.ReadOnlyField(source='author.username') # 추가

    class Meta:
        model = Post
        fields = ['pk', 'username', 'title', 'cotnent'] # 'username' 추가

_ 또는 StringRelatedField, SlugRelatedField 등 뿐만 아니라, 중첩된 Serializer를 통해서도 구현 가능합니다.

#serializers.py

from django.contrib.auth import get_user_model
from rest_framework import serializers
from .models import Post
class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = get_user_model()
        fields = ['username']

class PostSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Post
        fields = '__all__'

도움 받은 글들

https://sss20-02.tistory.com/65

[Django] JSON 직렬화 - Serializer

(Model)Form vs (Model)Serializer Django Djnago Rest Framework Form/ModelForm Serializer/ModelSerializer Model로부터 Field 읽어옴 유효성 검사 HTML Form 생성 JSON 문자열 생성 django와 django rest fra..

sss20-02.tistory.com

https://velog.io/@joje/JSON-%EC%A7%81%EB%A0%AC%ED%99%94-%EB%B0%8F-API-%EC%9D%91%EB%8B%B5-Django-vs-DRF

JSON 직렬화 및 API 응답 (Django vs DRF)

직렬화의 개념 및 방법에 대해서 알아본다. 또한 Django와 DRF에서 직렬화 룰을 추가하고 수행하는 예제를 살펴보고 JSON API 응답을 비교해본다.

velog.io

https://brownbears.tistory.com/82

[Django REST framework] ViewSet

ViewSets Django REST framework는 단일 클래스에서 관련있는 view들의 집합을 위해 logic의 결합을 허용합니다. 이를 ViewSet이라 합니다. 또한 다른 framework에서 resource 또는 controller같이 이름이 개념..

brownbears.tistory.com

Django JSON 응답뷰

개발자Dongbaek — Sat, 12 Mar 2022 14:27:40 +0900

처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django JSON 응답뷰 만들기

REST API 스타일로 포스팅 API 서비스를 제공할 때

/post/ 주소

GET 방식 요청 : 목록 응답
POST 방식 요청 : 새 글 생성하고, 확인 응답

예시 코드

def post_list(request):
    if request.method == 'POST':
        # POST 일시 새 글 저장을 구현
        form = PostForm(request.Post, request.FILES)
        if form.is_valid():
            post = form.save()
            # JsonResponse은 json 응답을 만드는데 사용합니다.
            # 유효성 검사에 통과했다면
            return JsonResponse(post)
        # 유효성 검사에 통과하지못했다면    
        return JsonResponse(form.errors)
    else:
        # GET 일시 목록 응답을 구현
        return JsonResponse(Post.objects.all())

/post/10/ 주소

GET 방식 요청 : 10번 글 내용 응답
PUT 방식 요청 : 10번 글 수정 / 저장하고, 확인 응답
DELETE 방식 요청 : 10번 글 삭제하고, 확인 응답

예시 코드

# 특정 pk에 대해 접근
def post_detail(request, pk):
    if request.method == 'PUT':
        # PUT 일시 해당 PK글 수정, 갱신을 구현
        # QueryDict은 사전형 타입의 클래스로 같은 키에 대해 복수의 값을 갖도록 커스터마이즈하게 해준다.
        put_data = QueryDict(request.body)
       
        # 해당 pk글을 수정할 instance로 둡니다.
        form = PostForm(put_data, instance=post)
        if form.is_valid():
            post = form.save()
            # JsonResponse은 json 응답을 만드는데 사용합니다.
            # 유효성 검사에 통과했다면
            return JsonResponse(post)
        # 유효성 검사에 통과하지못했다면    
        return JsonResponse(form.errors)
    
    elif request.method == 'DELETE':
        # DELETE 일시 해당 PK글 삭제를 구현
        post.delete()
        return HTTPResponse()
    
    else:
        # GET 일시 해당 PK글 내용 응답을 구현
        return JsonResponse(Post.objects.all())

총 5개의 뷰 처리가 필요해집니다.

_ 만약 다른 모델에 대해서 동일한 기능을 구현한다면, Model/Form을 제외하고는 위 코드와 같이 거의 정형화된 패턴입니다. Django REST Framework (=DRF)는 이런 정형화 된 중복을 줄일 수 있도록 도와주는 CBV를 비롯해 다양한 기능을 지원합니다.

참고

HTTP 동사(메소드)

_GET 메서드는 특정 리소스의 표시를 요청합니다. GET을 사용하는 요청은 오직 데이터를 받기만(조회) 합니다.

_POST 메서드는 특정 리소스에 엔티티를 제출할 때 쓰입니다, 즉 새 리소스를 생성 요청합니다. 이는 종종 서버의 상태의 변화나 부작용을 일으킵니다.

_PUT 메서드는 기존 리소스를 대체하고, 요청 본문에 갱신할 리소스 정보를 제공합니다.

_DELETE 메서드는 특정 리소스를 삭제합니다.

_PATCH 메서드는 리소스의 부분만을 수정하는 데 쓰입니다.

https://developer.mozilla.org/ko/docs/Web/HTTP/Methods

HTTP 요청 메서드 - HTTP | MDN

HTTP는 요청 메서드를 정의하여, 주어진 리소스에 수행하길 원하는 행동을 나타냅니다. 간혹 요청 메서드를 "HTTP 동사"라고 부르기도 합니다. 각각의 메서드는 서로 다른 의미를 구현하지만, 일부

developer.mozilla.org

DRF 설치하기

https://www.django-rest-framework.org/

Home - Django REST framework

www.django-rest-framework.org

0. 터미널에 아래 코드를 입력해줌으로서 설치를 해줍니다.

pip install djangorestframework~=3.11.0

추가로 항상 requirements.txt를 통해서 사용하고 있는 skill들을 기록해놓아야 합니다.

django~=3.0.0
djangorestframewrok~=3.11.0

1. settings.INSTALLED_APPS에 "rest_framework"를 추가해줍니다.

INSTALLED_APPS = [
    # Django Apps
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.humanize',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Third Apps
    'debug_toolbar',
    'bootstrap4',
    'django_pydenticon',
    'easy_thumbnails',
    'rest_framework', # 추가

    # Local Apps
    'accounts',
    'insta',
  
]

2. ulrpatterns 다음 패턴에 추가해줍니다.

urlpatterns = [
    path('api-auth', include('restframework.ulrs')), # 추가
]

DRF 샘플 구현하기 (매우 기본 샘플)

myapp/models.py

from django.db import models

# Create your models here.

class Post(models.Model):
    message = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

myapp/serializers.py

from rest_framework.serializers import ModelSerializer
from .models import Post

class PostSerializer(ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

myapp/views.py

from rest_framework.viewsets import ModelViewSet

from .serializers import PostSerializer
from .models import Post

class PostViewSet(ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer





"""
DRF를 사용하지 않았을 때의 작업 방법

def post_list(request):
    # 최소 2개의 분기 ex) POST, GET
    pass

def def_detail(request, pk):
    # request.method # => 최소 3개 분기 ex) GET, PUT, DELETE
    pass
"""

myapp/urls.py

from django.urls import path, include
from rest_framework.routers import DefaultRouter

from . import views

# 1개의 CBV에서 2개의 url을 만드는 코드
router = DefaultRouter()
router.register('post', views.PostViewSet) # 2개의 URL을 만들어줌.
# 위의 과정까지 마치면
# router.urls에 리스트 형태로 url들이 저장되어있음.


urlpatterns = [
    path('', include(router.urls)),
]

root 페이지의 모습

/post/ 페이지의 모습

DRF에서 기본 제공되는 로그인 페이지 // django의 auth를 이용

/post/ 페이지에서 POST를 했을 때 JSON 형태로 저장이 된다.

다양한 HTTP 클라이언트 프로젝트

_ 유저가 웹브라우저를 통해 웹페이지간 이동할때

_ 웹 프론트엔드에서 JavaScripts를 통해 호출 할 때 ex) Ajax

_ Android/ios 앱 코드를 통한 호출 할 때

_ 웹 요청 개발 프로그램을 통한 호출 할 때 ex) Postman, request ,HTTPie

그 중 HTTPie를 통한 HTTP 요청

https://codermun-log.tistory.com/144

TIL.54 Httpie를 이용해 통신해보기(Django, MySQL)

Django_CRUD_2 이전 CRUD_1에서는 모델과 데이터베이스간에 다뤘던 Django QuerySetAPI를 사용하고 연습해봄으로써 손에 익히기 위한 공부였다면 CRUD_2에서는 위에서 배운 내용1의 기본기를 통해서 실제로

codermun-log.tistory.com

설치는 아래 코드와 같습니다.

pip3 install httpie

HTTPie 명령어

https://ssungkang.tistory.com/entry/Web-%EC%82%AC%EC%9A%A9%EC%9E%90-%EC%B9%9C%ED%99%94%EC%A0%81%EC%9D%B8-http-client-Httpie

[Web] 사용자 친화적인 http client, Httpie

우리는 직접 웹사이트에 들어가지 않고도 정보를 얻을 수 있습니다. CLI 를 통해 명령어를 입력하는 것으로만으로 말이죠. 앞으로 공부할 django restful API 처럼 API 를 테스트 하는데도 사용할 수 있

ssungkang.tistory.com

쉘 > http GET 요청할주소 GET인자명==값 GET인자명==값

쉘 > http --json POST 요청할주소 GET인자명==값 GET인자명==값 POST인자명==값 POST인자명==값

-> 옵션 지정 : application/json -> 요청 데이터를 JSON 직렬화

쉘 > http --form POST 요청할주소 GET인자명==값 GET인자명==값 POST인자명==값 POST인자명==값

-> 옵션 지정 : multipart/form-data

쉘 > http PUT 요청할주소 GET인자명==값 GET인자명==값 PUT인자명==값 PUT인자명==값

쉘 > http DELETE 요청할주소 GET인자명==값 GET인자명==값

Django로 인스타그램 클론 코딩시 필요한 Skill

개발자Dongbaek — Sat, 12 Mar 2022 13:19:01 +0900

해당 요약 주소

회원가입 : 커스텀 유저, 아이디 / 암호 / 이메일 / 이름, 환영 이메일

https://devdongbaek.tistory.com/94

동백 // Django User 모델 커스텀 및 회원가입 구현

devdongbaek.tistory.com

https://devdongbaek.tistory.com/97

동백 // Django 회원 가입 이메일 보내기

devdongbaek.tistory.com

로그인 : 아이디 / 암호를 통한 로그인, 회원 가입과 동시에 로그인, 로그아웃

회원가입

https://devdongbaek.tistory.com/92

동백 // Django 회원가입, 로그인 구현하기!!!

devdongbaek.tistory.com

로그인, 로그아웃, 회원가입과 동시에 로그인, 로그아웃

https://devdongbaek.tistory.com/100

동백 // Django 로그인, 로그아웃 구현하기

devdongbaek.tistory.com

유저 프로필 수정 및 암호 재설정

프로필 수정

https://devdongbaek.tistory.com/104

동백 // Django 유저 프로필 수정

devdongbaek.tistory.com

암호 재설정

https://devdongbaek.tistory.com/105

동백 // Django 암호 수정 구현하기

devdongbaek.tistory.com

포스팅 쓰기 (사진 및 caption, 다수 태크, location 등록)

https://devdongbaek.tistory.com/108

동백 // Django 포스팅 쓰기 구현하기

devdongbaek.tistory.com

유저 페이지 구현

타임라인 : Follow 구현, Following 하는 User들의 포스팅 목록, 포스팅 좋아요, 댓글

python 가상환경을 사용하면 프로젝트별 라이브러리 관리가 아주 용이해 진다.

가상환경 설치 및 실행하기

https://velog.io/@full_accel/python-%EA%B0%80%EC%83%81%ED%99%98%EA%B2%BD

python - 가상환경

python은 생태계가 잘 구축된 언어이다. 즉, 유용한 라이브러리와 패키지들이 아주 많다. 이미지를 처리하고 싶으면 pillow를 쓰면 된다. 마크다운을 다뤄야 한다면 markdownx가 있다. 웹 페이지를 만

velog.io

설치하기

>>> python -m venv django_project

실행하기

>>> D:\venvs\django_project>cd Scripts >>> D:\venvs\django_project\Scripts>activate

가상환경이 실행되었는지 확인하기

(django_instagram) C:\Users\yardy\Desktop\DjangoPractice\django_instagram\Scripts>

성공적으로 실행이 되었으면 옆에 (가상환경이름) 이 뜸

>>>where django-admin

출력값이 가상환경 위치와 같아야한다. #혹 다를 경우 터미널을 재시작하여 다시 activate 해보자

https://velog.io/@hanmin_ss/Django-01.-%EA%B0%80%EC%83%81%ED%99%98%EA%B2%BD%EA%B3%BC-%EC%9E%A5%EA%B3%A0%EC%84%A4%EC%B9%98

!!반드시 가상환경을 먼저 설치 한 후에 그 안에 Django 파일을 설치해야합니다.!!!

장고 기본 환경 설치및 세팅하기

https://devdongbaek.tistory.com/48?category=1032015

동백 // Django 설치 및 프로젝트 생성

devdongbaek.tistory.com

Django 프로젝트 설치 후 해야할 일

0. requirements 폴더 생성 후 작업

requirements 폴더 생성후 폴더 아래에
commom.txt, dev.txt, prod.txt를 생성
- commom.txt : 공통 라이브러리를 붙여넣는 곳
- dev.txt : 개발용 라이브러리를 붙여넣는 곳
- prod.txt : 배포용 라이브러리를 붙여넣는 곳

commom.txt

django~=3.0.0

dev.txt

-r common.txt

prod.txt

-r common.txt

1. 템플릿 폴더, Static 폴더 생성 후 작업

템플릿들과 Static 파일들을 모아놓을 폴더를 생성한다. #보통 프로젝트의 제일 바깥에 둔다.

2. settings.py 작업

settings.py에 아래 코드들을 적어준다.

TEMPLATES = [ { """ 중략 """ 'DIRS': [ os.path.join(BASE_DIR, 'django_instagram' ,'templates'), ], """ 중략 """ } STATIC_URL = '/static/' STATICFILES_DIRS = [ os.path.join(BASE_DIR, 'instagram' , 'static'), ] STATIC_ROOT = os.path.join(BASE_DIR, 'static') MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media') INTERNAL_IPS = ['127.0.0.1']

DIRS에 프로젝트 이름과 1번 단계에서 만들어준 템플릿 폴더의 이름을 넣음
위 코드들을 통해서 model에서 FileField나 ImageField를 통해서 업로드 된 파일은 MEDIA 설정을 통해서 처리된다.
static을 통해서 업로드 된 파일들을 STATIC 설정을 통해 처리된다.

# VSC에서 Django의 코드의 색깔이 그냥 하얗게 나온다면?
VSC의 확장에서 Django를 설치하자!

3. urls.py 작업

from django.conf import settings from django.contrib import admin from django.urls import path, include from django.conf.urls.static import static urlpatterns = [ path('admin/', admin.site.urls), ] if settings.DEBUG: import debug_toolbar urlpatterns += [ path('__debug__/', include('debug_toolbar.urls')), ] urlpatterns += static(settings.MEDIA_URL, doucument_root =settings.MEDIA_ROOT)

4. 추가 pip 설치

>>>pip install django-debug-toolbar

pip 설치 후 꼭!! settings.py의 INSTALLED_APPS와 MIDDLEWARE에 추가해줘야 한다.

INSTALLED_APPS = [ # Django Apps # Third Apps 'debug-toolbar', # Local Apps ] MIDDLEWARE = [ "debug_toolbar.middleware.DebugToolbarMiddleware", ] INTERNAL_IPS = ['127.0.0.1']

5. settings 폴더 생성 및 코드 작성

settings.py를 settings 폴더로 옮기고 이름을 commons.py로 변경 시켜준다. 그리고
0단계에서 만들었던 파일들의 이름과 똑같은 py 파일들을 settings 폴더 밑에 만들어준다.

현 commons.py 전settings.py에 추가 코드 작업을 해준다

import os from os.path import abspath, dirname # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = dirname(dirname(dirname(abspath(__file__))))

dev.py

from .commons import *

최종 파일 트리

Django API와 REST

개발자Dongbaek — Thu, 10 Mar 2022 11:25:36 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django API와 REST

API 서버란?

_앱 / 웹 서비스를 만드는 개발자들이 이용하는 데이터 위주의 서비스 // request를 받으면, 서버측에서 주로 json으로 응답합니다.

_시간이 지나도 호환성을 유지해야 합니다.

앱 등의 유저가 사용하는 UI는 유저가 원할 때 업데이트가 됩니다.
유저층이 사용하는 앱의 버전이 다양하기에, API에도 버전 개념을 둡니다.
그에 반해, 웹 서비스를 이용하는 유저는 항상 최신 버전을 사용합니다. 그 이유는 웹 브라우저로 접속한 유저는 앱을 사용하는 유저와 다르게 웹브라우저에 접속할 때 최신버전의 HTML, css, js, static files를 다운받기 때문입니다.

REST란?

_Representational State Transfer :

HTTP URI(Uniform Resource Identifier)를 통해 자원(Resource)을 명시하고, HTTP Method(POST, GET, PUT, DELETE)를 통해 해당 자원에 대한 CRUD Operation을 적용하는 것을 의미한다.
https://gmlwjd9405.github.io/2018/09/21/rest-and-restful.html

_아키텍쳐 스타일을 REST라고 부르며, 프로토콜에 독립적입니다. 즉 어떠한 프로토콜에도 아키텍쳐를 적용할 수 있습니다.

_일반적인 REST 구현에서는 HTTP를 많이 사용합니다.

_RESTful API의 몇가지 디자인 원칙

리소스를 중심으로 디자인 -> ex) 장고 모델, 포스팅, 댓글, 프로필 사진 등등
- 리소스를 중심으로 한 API 구성 예시
  - /orders/ 로의 POST 요청 -> 리소스를 직접 명시해주는 것이 좋다.
  - ~~/create-order/ 로의 POST 요청~~ -> 동사는 url에 적합하지않다.
  - /customers/ -> 고객 컬렉션
  - /customers/5/ -> pk가 5인 고객 -> 직관적인 웹 API
  - /customers/5/orders/ -> 고객 5에 대한 모든 주문
  - /orders/99/customers/ -> 주문 99의 고객
- 심플하게 URL를 구성하기
  - /customers/1/orders/99/products/ -> 유연성이 떨어짐.
  - /customers/1/orders/ 를 통해서 고객 1의 모든 주문을 찾은 후에 주소를 /orders/99/products/ 로 변경해서 동일한 처리를 해줌 // 즉 주소가 길어질 시 분할해줌
클라이언트에서 액세스할 수 있는 모든 종류의 개체/서비스가 리소스에 포함함
리소스마다 해당 리소스를 고유하게 식별하는 식별자 -> ex) pk, id
- https://adventure-works.com/orders/1
요청/응답 포맷으로 흔히 JSON을 사용함 // 과거에는 xml을 사용했었음
균일한 인터페이스를 적용
- 리소스에 표준 HTTP 동사 (GET, POST, PUT, PATCH, DELETE)를 적용

HTTP 동사(메소드)

_GET 메서드는 특정 리소스의 표시를 요청합니다. GET을 사용하는 요청은 오직 데이터를 받기만(조회) 합니다.

_POST 메서드는 특정 리소스에 엔티티를 제출할 때 쓰입니다, 즉 새 리소스를 생성 요청합니다. 이는 종종 서버의 상태의 변화나 부작용을 일으킵니다.

_PUT 메서드는 기존 리소스를 대체하고, 요청 본문에 갱신할 리소스 정보를 제공합니다.

_DELETE 메서드는 특정 리소스를 삭제합니다.

_PATCH 메서드는 리소스의 부분만을 수정하는 데 쓰입니다.

https://developer.mozilla.org/ko/docs/Web/HTTP/Methods

HTTP 요청 메서드 - HTTP | MDN

developer.mozilla.org

요청 / 응답 형식 지정

_요청 : Content-Type 헤더

ex) application/json, image/jpeg, application/pdf 등 요청시에 처리를 원하는 형식을 url에 지정하면, 서버에서는 해당 형식으로 응답합니다.

_서버에서 해당 형식을 지원하지 않는다면 HTTP 상태 코드 415 (지원하지 않는 미디어 유형)을 반환합니다.

django-rest-framework

_ 장고의 패러다임 하에 빠르고 관리하기 쉬운 API를 만들 수 있습니다.

_ DRF는 REST API 컨셉을 쉽게 만들 수 있도록 도와줍니다.

_ Serializer / ModelSerializer를 통한 데이터 유효성 검증 및 데이터 직렬화 -> Json

_ 각종 Parser를 통한 데이터 처리

_ APIView / Generic / ViewSet / ModelViewSets 를 통한 요청 처리

_ 각종 Render를 통한 다양한 응답 포맷 지원 -> xml, pdf, excel etc...

_ 인증(Authentication) / 권한(Permission) 체계 -> 써트파티를 통한 JWT 지원

_ Throttling (최대 호출 횟수 제한)

https://www.django-rest-framework.org/

Home - Django REST framework

www.django-rest-framework.org

REST API는 단순히 URL 형식만 맞춰준다고 REST API가 되는게, 아닙니다.

_URL은 'http://{serviceRoot}/{collection}/{id}' 형식이어야 합니다.

_ GET, PUT, DELETE, POST, HEAD, PATCH, OPTIONS를 지원해야합니다.

_ API 버저닝은 Major.minor로 하고, URL에 버전 정보를 포함시킵니다.

프레임워크를 쓴다는 것은, 그 프레임워크가 제시하는 길을
명확히 이해하고 존중하는 것에서 시작합니다.

참고 문서 및 추가 용어 정리

https://docs.microsoft.com/ko-kr/azure/architecture/best-practices/api-design

웹 API 디자인 모범 사례 - Azure Architecture Center

플랫폼 독립성과 서비스 진화를 지원하는 웹 API 설계를 위한 모범 사례를 알아봅니다.

docs.microsoft.com

_아키텍쳐란??

최적화를 목표로 두고, 스템 구성과 동작원리 그리고 시스템의 구성환경등을 설명 및 설계하는 청사진 또는 설계도

https://tuhbm.github.io/2019/04/24/architecture/

아키텍처란 무엇인가?

용어정리이 카테고리는 비전공자로서 개발자로써 공부하며, 평소 이해하지 못한 단어를 제방식대로 정리하는 카테고리입니다.제방식대로 풀어 쓴것이므로 오류가 있을 수 있습니다.오류가 있

tuhbm.github.io

_아키텍쳐 스타일이란??

아키텍처 설계에서 반복해서 나타나는 문제를 해결하고 아키텍처가 만족 시켜야하는 시스템 품질 속성을 달성할 수 있는 방법을 정리한 문서

https://itpenote.tistory.com/76

소프트웨어 아키텍처 스타일(Software Architecture Style)

MVC (Model, View, Control), 저장소, 클라이언트-서버, 데이터플로우, 계층형 I. 시스템 품질 향상을 위한 패턴, 소프트웨어 아키텍처 스타일의 개요 가. 소프트웨어 아키텍처 스타일(Software Architecture Sty

itpenote.tistory.com

Django 댓글 구현하기

개발자Dongbaek — Wed, 23 Feb 2022 13:05:53 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django 댓글 구현하기

#insta/models.py

class BaseModel(models.Model):

    class Meta:
        # 아래 코드를 통해 실제 DB에 적용되지 않고, 추상 클래스로 만들어진다.
        abstract = True


class Comment(BaseModel):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    message = models.TextField()

    class Meta:
        ordering = ['-id']

_ 항상 모델단에 ordering을 통해 정렬을 하는것을 추천합니다.

_ Django에서는 정수나 날짜등을 사람이 보기 보다 편하게 해주는 템플릿 필터가 존재합니다.

ex) 예를 들어 숫자에 컴마를 찍어준다거나, 날짜를 today, yesterday등으로 바꿔줍니다.

https://docs.djangoproject.com/en/4.0/ref/contrib/humanize/

django.contrib.humanize | Django documentation | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

_반드시 humanize를 INSTALLED_APPS에 먼저 추가 시켜주어야 합니다.

INSTALLED_APPS = [
    # Django Apps

    'django.contrib.humanize', # 추가

]

#insta/templates/insta/_post_card.html

{% load bootstrap4 humanize insta_tags  %}

<div class="card">
    <div class="card-header">    
        <img src= "{{ user.profile_url }}" style="width: 24px; height: 24px;"/>
        <a href="{% url "insta:user_page" post.author.username %}" style="text-decoration:none">
            {{ post.author }}    
        </a>                
    </div>
    
    <div class="card-body">   
        {% if post.photo.url %}
            <img src="{{ post.photo.url  }}" style="width: 100%;"/>
        {% endif %}  
        <div>
            {% if post|is_like_user:user %}
                <a href="{% url 'insta:post_unlike' post.pk %}" style="text-decoration:none">
                    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#FF0000" class="bi bi-heart-fill" viewBox="0 0 16 16">
                        <path fill-rule="evenodd" d="M8 1.314C12.438-3.248 23.534 4.735 8 15-7.534 4.736 3.562-3.248 8 1.314z"/>
                    </svg>
                </a>
            {% else %}
                <a href="{% url 'insta:post_like' post.pk %}" style="text-decoration:none">
                    <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#FF0000" class="bi bi-heart" viewBox="0 0 16 16">
                        <path d="m8 2.748-.717-.737C5.6.281 2.514.878 1.4 3.053c-.523 1.023-.641 2.5.314 4.385.92 1.815 2.834 3.989 6.286 6.357 3.452-2.368 5.365-4.542 6.286-6.357.955-1.886.838-3.362.314-4.385C13.486.878 10.4.28 8.717 2.01L8 2.748zM8 15C-7.333 4.868 3.279-3.04 7.824 1.143c.06.055.119.112.176.171a3.12 3.12 0 0 1 .176-.17C12.72-3.042 23.333 4.867 8 15z"/>
                    </svg> 
                </a>
            {% endif %}
        </div>

        <div class="comment-list mt-3 mb-3">
            {% for comment in post.comment_set.all %}
            <div class="comment">
                <strong>{{ comment.author }}</strong>
                {{ comment.message }}
                <small class="text-muted">{{ comment.created_at|naturaltime }}</small>
            </div>
            {% endfor %}
        </div>

        <div>
            {% for tag in post.tag_set.all %}
                <span class="badge badge-primary" style="color: #fff;
                background-color: #007bff;">                        
                    #{{ tag.name }}
                </span>
            {% endfor %}  
        </div>         
        
        <div>
            <a href="{{ post.get_absolute_url }}" style="text-decoration:none" class="text-muted">
                <small>
                    {{ post.created_at|naturaltime }}
                </small>
            </a>
        </div>    
    </div>
    
    <div class="card-footer">                           
        <a href="{% url 'insta:comment_new' post.pk %}">
            댓글 쓰기
        </a>
    </div>
</div>

_반드시 템플릿 최상단에 humanize를 load 해주어야 오류가 안납니다!

#insta/forms.py

from django import forms
from .models import Post, Comment


class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields =  [
            'photo', 'caption', 'location'
        ]

        # 장고에서는 widgets 를 통해 특정 필드 위젯을 변경할 수 있다.
        widgets = {
            "caption" : forms.Textarea,
        }


class CommentForm(forms.ModelForm):
    class Meta:
        model = Comment
        fields = ["message"]

#insta/urls.py

urlpatterns = [

    # 아래 path에서는 comment가 주인공이기에 post_pk로 작성
    path('post/<int:post_pk>/comment/new/', views.comment_new, name='comment_new'),

    ]

#insta/views.py

# 댓글 쓰기
@login_required
def comment_new(request, post_pk):
    post = get_object_or_404(Post, pk=post_pk)

    if request.method == 'POST':
        form = CommentForm(request.POST, request.FILES)
        if form.is_valid():
            # 내부적으로 comment가 save되는 것을 막음 
            # 그 이유는 댓글 폼은 message 필드만 받기 때문에, 나머지 필드에서 오류가 생기기 때문이다.
            # 그러기에 나머지 필드를 채워준 상태에서 form을 저장 시켜야한다.
            comment = form.save(commit=False)
            comment.post = post
            comment.author = request.user
            comment.save()
            return redirect(comment.post)    
    else:
        form = CommentForm()
    return render(request, "insta/comment_form.html", {
        "form" : form,
    })

_ commit=False를 쓰는 이유는?

예를 들어서 필드가 4개가 있는 모델을 모델 폼으로 작성을 받을 때

나는 그 중 1개의 필드만 폼으로 작성하고 싶다!!

이 경우에 view 함수에서 유효성 검사 이후 form.save()를 먼저 하면 나머지 필드들은 값을 받지

못했으므로 오류가 발생합니다!

그러기에 우리는 장고에게 잠시만 저장을 미뤄줘~~! 라는 의미로 commit=False를 적어준 다음

나머지 필드들의 값을 지정해주는겁니다!

#insta/templates/insta/comment_form.html

{% extends "insta/layout.html" %}
{% load bootstrap4 %}

{% block content %}
    <div class="container">
        <div class="row">
            <div class="col-sm-6 offset-sm-3">
                {% include "_form.html" with form_title="새 댓글 쓰기" submit_label="새 댓글 쓰기"  %}
            </div>
        </div>
    </div>  
{% endblock %}

Django 포스팅 좋아요 기능 구현하기

개발자Dongbaek — Tue, 22 Feb 2022 22:44:31 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django 포스팅 좋아요 / 취소 구현하기

#insta/models.py

class Post(BaseModel):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, related_name="my_post_set", on_delete=models.CASCADE)
    # 중략
    like_user_set = models.ManyToManyField(settings.AUTH_USER_MODEL, related_name="like_post_set", blank=True)

_필드의 related_name 옵션을 설정해주면, 쿼리셋시에 related_name을 이용하여 모델 객체를 불러올 수 있습니다.

ex)

기존 -> Post.objects.filter(author=user)

related_name -> user.my_post_set.all()

_related_name 이란

참조되는 테이블이 참조하는 테이블의 데이터를 가져오고 싶을 때 사용하는 이름을 정의하는 것입니다,

_ManyToManyField 란??

https://velog.io/@jiffydev/Django-9.-ManyToManyField-1

Django 9. ManyToManyField 1

1. Many-to-Many relationship 데이터베이스의 Many-to-Many relationship(이하 다대다 관계)는 처음 접하는 사람들을 힘들게 한다. 한 테이블의 여러 레코드가 다른 테이블의 여러 레코드와 연결되어 있는 관계

velog.io

_user.my_post_set은 유저가 작성한 포스팅에 접근하게 되고, user.like_post_set은 유저가 좋아요를 누른 포스팅에 접근하게 됩니다.

#insta/urls.py

urlpatterns = [    
    path('post/<int:pk>/like', views.post_like, name='post_like'),
    path('post/<int:pk>/unlike', views.post_unlike, name='post_unlike'),
    ]

_ post_detail에 맞게 즉 포스팅 디테일뷰가 보여지는 url과 똑같이 매핑합니다.

#insta/views.py

# 포스팅 좋아요
@login_required
def post_like(request, pk):
    post = get_object_or_404(Post, pk=pk)
    
    post.user_like_set.add(request.user)
    
    messages.success(request, f"{post}를 좋아합니다.")
    
    redirect_url = request.META.get("HTTP_REFERER", "root") # HTTP_REFERER은 request 요청을 한 웹페이지의 주소를 보여준다.
    # 만약 HTTP_REFERER가 없으면 root 주소를 가져온다.
    return redirect(redirect_url)


# 포스팅 싫어요
@login_required
def post_unlike(request, pk):
    post = get_object_or_404(Post, pk=pk)
    
	post.user_like_set.remove(request.user)


	messages.success(request, f"{post}를 좋아요를 취소합니다.")
    
    redirect_url = request.META.get("HTTP_REFERER", "root") # HTTP_REFERER은 request 요청을 한 웹페이지의 주소를 보여준다.
    # 만약 HTTP_REFERER가 없으면 root 주소를 가져온다.
    return redirect(redirect_url)

_ request.META.get()이란??

request.META는 사용자의 IP 주소와 사용자 Agent(일반적으로 웹 브라우저의 이름과 버전)를 포함해 지정된 요청에 대해 사용할 수 있는 모든 HTTP 헤더가 들어있는 파이썬 딕셔너리 입니다.

출처 : https://yonghyunlee.gitlab.io/python/django-master-6/

템플릿단

#insta/templates/insta/_post_card.html

{% load bootstrap4 %}
{% load insta_tags %}


<div class="card">
    <div class="card-header">    
        <img src= "{{ user.profile_url }}" style="width: 24px; height: 24px;"/>
        <a href="{% url "insta:user_page" post.author.username %}" style="text-decoration:none">
            {{ post.author }}    
        </a>                
    </div>
    <div class="card-body">   
        {% if post.photo.url %}
            <img src="{{ post.photo.url  }}" style="width: 100%;"/>
        {% endif %}  
        {% for tag in post.tag_set.all %}
            <span class="badge badge-primary" style="color: #fff;
            background-color: #007bff;">                        
                #{{ tag.name }}
            </span>
        {% endfor %}                         
    </div>
    <div class="card-footer">                           
        
        {% if post|is_like_user:user %}
            <a href="{% url 'insta:post_unlike' post.pk %}" style="text-decoration:none">
                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#FF0000" class="bi bi-heart-fill" viewBox="0 0 16 16">
                    <path fill-rule="evenodd" d="M8 1.314C12.438-3.248 23.534 4.735 8 15-7.534 4.736 3.562-3.248 8 1.314z"/>
                </svg>
            </a>
        {% else %}
            <a href="{% url 'insta:post_like' post.pk %}" style="text-decoration:none">
                <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#FF0000" class="bi bi-heart" viewBox="0 0 16 16">
                    <path d="m8 2.748-.717-.737C5.6.281 2.514.878 1.4 3.053c-.523 1.023-.641 2.5.314 4.385.92 1.815 2.834 3.989 6.286 6.357 3.452-2.368 5.365-4.542 6.286-6.357.955-1.886.838-3.362.314-4.385C13.486.878 10.4.28 8.717 2.01L8 2.748zM8 15C-7.333 4.868 3.279-3.04 7.824 1.143c.06.055.119.112.176.171a3.12 3.12 0 0 1 .176-.17C12.72-3.042 23.333 4.867 8 15z"/>
                </svg> 
            </a>
        {% endif %}
    </div>
</div>

{{ post|is_like_user:user }}

_ Pipe(='|') 앞의 인자"post"는 tags.py 함수의 첫번째 인자로 넘어가고, "user"은 두번째 인자로 넘어갑니다.

아래 코드는 위 이해를 돕기위한 tags.py의 함수입니다.

@register.filter
def is_like_user(post, user):
    # 해당 글의 is_like_user를 반환 하여줍니다.
    return post.is_like_user(user)

_위 tags.py 함수는 모델단의 함수를 호출시켜줍니다.

    # 만약 유저가 포스팅을 좋아한다면(=like_user_set에 유저 pk가 있다면) True를 반환
    def is_like_user(self, user):
        return self.like_user_set.filter(pk=user.pk).exists()

템플릿에서 -> tags.py 함수 호출 -> tags.py에서 model단 함수 호출

_ 아이콘을 지원해주는 사이트들

https://icons.getbootstrap.kr/

Bootstrap Icons

Bootstrap을 위한 공식 오픈 소스 SVG 아이콘 라이브러리

icons.getbootstrap.kr

https://fontawesome.com/icons

Font Awesome

The world’s most popular and easiest to use icon set just got an upgrade. More icons. More styles. More Options.

fontawesome.com

_장고 템플릿 단에서 함수를 호출하고, 인자를 넘기고 싶다면 Django custom templates filter를

적용해야합니다.

https://docs.djangoproject.com/ko/4.0/howto/custom-template-tags/

How to create custom template tags and filters | Django 문서 | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

0. 해당 앱에 templatestags 라는 폴더를 만들어줍니다.

1. templatestags 폴더 안에 '__init__.py'와 'app이름_tags.py'를 만들어줍니다.

#insta/templatetags/insta_tags.py

from django import template

register = template.Library()


@register.filter
def is_like_user(post, user):
    # 해당 글의 is_like_user를 반환 하여줍니다.
    return post.is_like_user(user)

Django 인스타그램 글에 기간 설정하기

개발자Dongbaek — Mon, 21 Feb 2022 18:00:38 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django 인스타그램 포스팅 글에 기간 설정하기

#insta/models.py

    # auto_now_add 는 생성 시간이 자동으로 DB에 저장된다.
    created_at = models.DateField(auto_now_add=True)
    # auto_now는 수정 시간이 DB에 자동으로 저장된다.
    updated_at = models.DateField(auto_now=True)

# 생성 시각 필드를 만들어준다.

_ 위 필드들과 같이 매번 모델에 들어가는 필드들이면 부모 추상 클래스를 통해서 코드 작성 시간을 줄일 수 있다.

class BaseModel(models.Model):

    class Meta:
        # 아래 코드를 통해 실제 DB에 적용되지 않고, 추상 클래스로 만들어진다.
        abstract = True

class Post(BaseModel):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    photo = models.ImageField(upload_to="insta/post/%Y%m%d")
    # 내용
    caption = models.TextField()
    tag_set = models.ManyToManyField('Tag', blank=True)
    location = models.CharField(max_length=100) 
    created_at = models.DateField(auto_now_add=True)
    updated_at = models.DateField(auto_now=True)

_후 Terminal에서 아래와 같이 필수 필드 여부에 대해서 작성해준다.

(django_instagram) C:\django_instagram>python manage.py makemigrations insta
You are trying to add the field 'created_at' with 'auto_now_add=True' to post without a default; the database needs something to populate existing rows.

 1) Provide a one-off default now (will be set on all existing rows)
 2) Quit, and let me add a default in models.py
Select an option: 1
Please enter the default value now, as valid Python
You can accept the default 'timezone.now' by pressing 'Enter' or you can provide another value.
The datetime and django.utils.timezone modules are available, so you can do e.g. timezone.now
Type 'exit' to exit this prompt
[default: timezone.now] >>> timezone.now
Migrations for 'insta':
  insta\migrations\0004_auto_20220221_1747.py
    - Add field created_at to post
    - Add field updated_at to post

# timezone.now를 default 값으로 넣어준다는 의미이다.

#insta/views.py

from datetime import timedelta
from django.utils import timezone

@login_required
def index(request):
    # 현재를 기준으로 3일 이내라면
    timesince = timezone.now() - timedelta(days=3)

    # TimeLine에 Follow하는 유저들의 포스팅 만을 노출하기
    post_list = Post.objects.all()\
        .filter( 
            Q(author=request.user) | 
            Q(author__in=request.user.following_set.all())
            )\
        .filter(
            created_at__lte = timesince # 3일 이내의 게시글
            #created_at__gte = timesince # 3일 이외의 게시글
        )

https://velog.io/@may_soouu/Django-%EB%A9%94%EC%86%8C%EB%93%9C-%EC%A0%95%EB%A6%AC

Django 메소드 정리

장고의 메소드에 대해 정리해보자일치하는 조건을 입력할 때 사용언더바 두개 (\_\_)\-조건을 사용할 경우 \-외부 모델 필드를 사용할 경우 부분 일치 조건 입력할 때 사용여러 조건을 포함할 경

velog.io

https://www.slideshare.net/EunhyangKim2/ss-118560530

Django의 배신(주니어 개발자의 Django 삽질기)

Dev Django Korea 2018에서 발표한 자료입니다. 주니어 개발자가 Django로 개발하며 삽질한 내용을 담았습니다.

www.slideshare.net

Django 인스타그램 follow 기능 구현

개발자Dongbaek — Thu, 17 Feb 2022 18:53:06 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Instagram Follow-Unfollow 기능 구현

#accounts/models.py

class User(AbstractUser):
	    follower_set = models.ManyToManyField("self", blank=True) # 현재 유저를 팔로우 하는 사람의 목록
    	# "self"를 통해서 대상을 User간의 관계로 지정할 수 있다.
    	following_set = models.ManyToManyField("self", blank=True) # 현재 유저가 팔로우 하는 사람의 목록

#accounts/urls.py

   urlpatterns = [
       re_path(r'^(?P<username>[\w.@+-]+)/follow/$', views.user_follow, name='user_follow'),  
       re_path(r'^(?P<username>[\w.@+-]+)/unfollow/$', views.user_unfollow, name='user_unfollow'),      
    ]

#accounts/views.py

# 팔로우 기능 
@login_required
def user_follow(request, username):
    follow_user = get_object_or_404(get_user_model(), username=username, is_active=True)
    
    # request.user -> follow_user를 팔로우 하려고 함.
    request.user.following_set.add(follow_user)
    # 반대로 팔로잉 된 유저의 follower_set에 현재 유저 추가
    follow_user.follower_set.add(request.user)

    messages.success(request, f"{follow_user}님을 팔로우 하였습니다.")
    redirect_url = request.META.get("HTTP_REFERER", "root") # HTTP_REFERER은 request 요청을 한 웹페이지의 주소를 보여준다.
    # 만약 HTTP_REFERER가 없으면 root 주소를 가져온다.
    return redirect(redirect_url)


# 언팔로우 기능
@login_required
def user_unfollow(request, username):
    unfollow_user = get_object_or_404(get_user_model(), username=username, is_active=True)

    # request.user -> follow_user를 팔로우 하려고 함.
    request.user.following_set.remove(unfollow_user)
    # 반대로 팔로잉 된 유저의 follower_set에 현재 유저 추가
    unfollow_user.follower_set.remove(request.user)

    messages.success(request, f"{unfollow_user}님을 언팔로우 하였습니다.")
    redirect_url = request.META.get("HTTP_REFERER", "root")
    return redirect(redirect_url)

https://docs.djangoproject.com/en/4.0/ref/request-response/

#insta/views.py


@login_required
def index(request):
    suggested_user_list = get_user_model().objects.all()\
        .exclude(pk=request.user.pk)\
        .exclude(pk__in=request.user.following_set.all())[:3] # 이미 팔로잉 하고 있는 유저들을 제외함.
        
    # 유저 본인 pk를 제외하고 나머지 유저가 suggested_user이다.
    return render(request, "insta/index.html", {
        "suggested_user_list" : suggested_user_list,
    })

템플릿 단

#insta/templates/insta/timeline_sidebar.html

<div class="card mb-2">
    <div class="card-header text-muted">
        Suggestions for you
    </div>
    <div class="card-body text-muted">
        {% for suggested_user in suggested_user_list %}
            {% include 'insta/timeline_sidebar_user_follow.html'%}
        {% empty %}
            추천 친구가 없습니다.
        {% endfor %} 
    </div>
</div>

#insta/templates/insta/timeline_sidebar_user_follow.html

<div class="d-flex">
    <div class="mr-3">
        <img src="{{ suggested_user.profile_url }}" style="width: 32px; height: 32px;" class="rounded-circle"/>}
    </div>
    <div class="p-2">
        {{ suggested_user.username }}
    </div>
    <div class="ml-auto">
        <a href="{% url "user_follow" suggested_user.username %}">Follow</a>
        <a href="{% url "user_unfollow" suggested_user.username %}">Unfollow</a>
    </div>
  </div>

#insta/templates/insta/index.html

{% extends "insta/layout.html" %}

{% block content %}
    <div class="container">
        <div class="row">
            <div class="col-sm-12">
                <a href="{% url 'insta:post_new' %}" class="btn btn-primary">새 포스팅 쓰기</a>             
            </div>
        </div>
        <div class="row">
            <div class="col-sm-8">     
                Timeline        
                <hr />
                {{ user.following_set.all }}   
            </div>
            <div class="col-sm-4">
                {% include "insta/timeline_sidebar.html" %}
            </div>
        </div>
    </div>
{% endblock %}

Django 인스타그램 Timeline sidebar 구현하기

개발자Dongbaek — Thu, 17 Feb 2022 16:18:31 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Instagram Timeline sidebar 구현

#insta/views.py

@login_required
def index(request):
    return render(request, "insta/index.html", {
    })

#insta/urls.py

urlpatterns = [
    path('', views.index, name='index'), #추가

    path('post/new', views.post_new, name='post_new'),
    path('post/<int:pk>', views.post_detail, name='post_detail'),


    re_path(r'^(?P<username>[\w.@+-]+)/$', views.user_page, name='user_page'),    
    ]

#프로젝트/urls.py

urlpatterns = [
    path('admin/', admin.site.urls),
    path('accounts/' , include('accounts.urls')),
   #path('', include('insta.urls')), 기존 주소 
    path('insta', include('insta.urls')), # 추가

    path('', login_required(TemplateView.as_view(template_name='root.html')), name='root' ), # re_path를 사용하면 모든 주소에 매칭이 된다.
    path('identicon/images/<path:data>/', pydenticon_image, name='pydenticon_image'),

]

# 프로젝트 urls.py에서 기존 root 주소(=' ')를 가지고있던 instagram의 주소를 'instagram/' 으로 지정해주므로

주소가 동일해지는 충돌을 피할 수 있습니다.

#프로젝트/templates/프로젝트/root.html -> insta/templates/insta/index.html 으로 이동

{% extends "insta/layout.html" %}

{% block content %}
    <div class="container">
        <div class="row">
            <div class="col-sm-12">
                <a href="{% url 'insta:post_new' %}" class="btn btn-primary">새 포스팅 쓰기</a>             
            </div>
        </div>
        <div class="row">
            <div class="col-sm-8">     
                Timeline           
            </div>
            <div class="col-sm-4">
                {% include "insta/timeline_sidebar.html" %}
            </div>
        </div>
    </div>
{% endblock %}

#insta/templates/insta/timeline_sidebar.html

<div class="d-flex p-2">
    <div class="mr-4">
        <img src="{{ user.profile_url }}" style="width: 40px; height: 40px;" class="rounded-circle"/>
    </div>
    <div>
        {{ user.username }}<br/>
        <small class="text-muted">{{ user.name }}</small>
    </div>
</div>

<div class="card mb-3">
    <div class="card-header text-muted">
        Stories
    </div>
    <div class="card-body text-muted">
        Stories from people you follow will show up
    </div>
</div>
            
<div class="card mb-2">
    <div class="card-header text-muted">
        Suggestions for you
    </div>
    <div class="card-body text-muted">
        {% include 'insta/timeline_sidebar_user_follow.html' with friend_user=user%}
        {% include 'insta/timeline_sidebar_user_follow.html' with friend_user=user%}
        {% include 'insta/timeline_sidebar_user_follow.html' with friend_user=user%}
    </div>
</div>

# with friend_user=user의 의미는 user(=현재 로그인 유저)를 friend_user로 넘기겠다는 의미입니다.

# 템플릿 내에서 반복되는 문장이 있다면 따로 템플릿을 만들어 include로 불러오는 방법을 추천합니다.

#insta/templates/insta/timeline_sidebar_user_follow.html

<div class="d-flex">
    <div class="mr-3">
        <img src="{{ friend_user.profile_url }}" style="width: 32px; height: 32px;" class="rounded-circle"/>}
    </div>
    <div class="p-2">
        {{ friend_user.username }}
    </div>
    <div class="ml-auto">
        <a href="#">Follow</a>
    </div>
  </div>

Django 유저 썸네일 구현

개발자Dongbaek — Wed, 16 Feb 2022 14:28:54 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

easy-thumbnail을 활용하여 프로필 디폴트 이미지 구현

https://github.com/SmileyChris/easy-thumbnails

GitHub - SmileyChris/easy-thumbnails: Easy thumbnails for Django

Easy thumbnails for Django. Contribute to SmileyChris/easy-thumbnails development by creating an account on GitHub.

github.com

https://wikidocs.net/10485

10) 썸네일 이미지

[TOC] # 패키지 선택 [Django 썸네일 이미지 라이브러리 비교](https://djangopackages.org/grids/g/thumbnails/) 사이트에서 ...

wikidocs.net

#Terminal

pip install easy-thumbnails

#commons.py(=settings.py)

INSTALLED_APPS = [
    # Django Apps
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # Third Apps
    'debug_toolbar',
    'bootstrap4',
    'django_pydenticon',
    'django_easythumbnails', # 추가

    # Local Apps
    'accounts',
    'insta',
  
]

# 후에 migrate를 해주어야 한다.

python manage.py migrate easy_thumbnails

# 템플릿 단에서 사용하기

#insta/templates/insta/user_page.html

        <div class="row mt-3">
            {% for post in post_list %}
                <div class="col-sm-4 mb-3">
                    <img src="{% thumbnail post.photo 256x256 crop %}" alt="{{ post.caption }}" style="width: 100%;%" />
                </div>
            {% endfor %}
        </div>

# thumbnail을 사용하면 url까지 작성하지 않아도 되고, 파일의 크기를 지정할 수 있다.

파이썬 해시법

개발자Dongbaek — Tue, 15 Feb 2022 19:05:05 +0900

해시법

해시법이란 '데이터를 저장할 위치 = 인덱스'를 간단한 연산으로 구하는 것을 의미한다.

아래의 표를 보며 해시법의 단어들을 자세히 설명해보겠습니다.

키			5	6	14	21	25	34
해시값(6으로 나눈 나머지)			5	0	2	3	1	4

이렇게 키의 값을 배열의 크기(길이)나 특정 기준으로 나눈 것을 해시값이라고 합니다.

해시값은 데이터에 접근할 때 기준 인덱스가 됩니다.

위에서 구한 해시값을 인덱스로 하여 원소를 새로 저장한 배열을 해시 테이블이라고하며, 아래와 같습니다.

-키를 해시값으로 변환하는 과정(나누는 과정)을 해시 함수라고 합니다.

_해시 테이블에서 만들어진 원소(=배열 한 칸)를 버킷이라고 합니다.

_만약 위의 해시 테이블에 18이라는 키값을 추가하고 싶을 때

18의 나머지는 0 즉 해시값이 0이므로, 0에는 이미 6이라는 값이 들어있습니다.

이때 저장할 버킷이 중복되는 현상을 충돌이라고 합니다.

해시법에서 충돌을 해결하는 방법은 총 2가지가 있습니다.

1. 체인법 : 해시값이 같은 원소를 연결리스트로 관리하는 것

2. 오픈 주소법 : 빈 버킷을 찾을 때 까지 해시를 반복하는 것

먼저 체인법에 대해서 알아보겠습니다.

_체인법이란 해시값이 같은 데이터를 체인 모양의 연결 리스트로 연결하는 방법을 말하며, 오픈 해시법이라고도 합니다.

#해시법에서 해시값을 각 버킷에 저장할 때는 해시값 인덱스에 바로 저장하는 것이 아닌 인덱스를 해시값으로 하는 연결 리스트의 앞쪽 노드를 참조하는 것입니다.

체인법을 파이썬으로 구현하기 위해서는 먼저 Node 클래스와 ChainedHash 클래스를 만들어야 합니다.

먼저 Node 클래스는 개별 버킷을 나타내며 키에 해시 함수를 적용하여 해시값을 구합니다.

_Node 클래스

from typing import Any, Sequence

class Node:
    # 해시를 구성하는 노드

    def __init__(self, key: Any, value: Any, next: Node) -> None:
        """ 초기화 """

        self.key = key     # 키
        self.value = value # 해시값
        self.next = next   # 뒤쪽 노드를 참조

_ChainedHash 클래스

from typing import Any, Sequence

class ChainedHash:
    # 해시를 구성하는 노드

    def __init__(self, capacity: int) -> None:
        """ 초기화 """

        self.capacity = capacity                # 해시 테이블의 길이 지정
        self.table = [None] * self.capacity     # 해시 테이블(리스트) 선언


    def hash_value(self, key: Any) -> int:
        """ 해시 값을 구하는 해시 함수 """

        if isinstance(key, int):
            return key % self.capacity

키로 원소 검색하기

_ 파이썬 코드

    def search(self, key: Any) -> Any:
        """ 키가 key인 원소를 발견하면 값을 반환 """
        hash = self.hash_value(key) # 해시 함수로 만든 해시 값
        p = self.table[hash]        # 해시 값의 인덱스를 p로 지정

        while p is not None:
            if p.key == key:        
                return p.value      # 검색 성공 
            p = p.next              # 뒤쪽 노드로 이동

        return None # 끝까지 찾지 못하였으므로 실패 반환

코드 프로세스

1. 해시 함수를 사용하여 키를 해시값으로 변환합니다.

2. 해시값을 인덱스로하는 버킷에 주목(=변수로 지정)합니다.

3. 버킷이 참조하는 연결 리스트를 맨 앞부터 차례로 스캔하며, 키와 같은 값이 발견되면 검색에 성공하고, 원소의

맨 끝까지 스캔했음에도 같은 값이 발견되지않는다면 검색에 실패합니다.

원소를 추가하기

_ 파이썬 코드

    def add(self, key: Any, value: Any) -> bool:
        """ 키가 key이고 값이 value인 원소를 추가 """

        hash = self.hash_value(key) # 해시 함수로 만든 해시 값
        p = self.table[hash]        # 해시 값의 인덱스를 p로 지정

        while p is not None:
            if p.key == key:        
                return False        # 검색 성공 
            p = p.next              # 뒤쪽 노드로 이동

        temp = Node(key, value, self.table[hash]) # temp라는 노드 만들기
        self.table[hash] = temp                   # 만든 노드 해시값에 참조 시키기
        return True                               # 추가 성공

코드 프로세스

1. 해시 함수를 사용하여 키를 해시값으로 변환합니다.

2. 해시값을 인덱스로 하는 버킷에 주목합니다.

3. 버킷이 참조하는 연결리스트를 맨 앞부터 차례로 선형검색합니다.

키와 같은 값이 발견되면 이미 키가 등록되어있는 경우이기에 추가에 실패합니다.만약 원소 끝까지 발견 되지 않으면 해시값인 리스트의 맨 앞에 노드를 추가합니다

원소를 삭제하기

_ 파이썬 코드

    def remove(self, key: Any) -> bool:
        """ 키가 key인 원소를 삭제 """

        hash = self.hash_value(key) # 해시 함수로 만든 해시 값
        p = self.table[hash]        # 해시 값의 인덱스를 p로 지정
        pp = None                   # 바로 앞의 노드를 주목

        while p is not None:
            if p.key == key:        # 키를 발견하면 아래를 실행
                if pp is None:        
                    self.table[hash] = p.next   # 뒤쪽 노드가 삭제할 값을 무시하고 해시값에 참조하게 합니다.
                else:
                    pp.next = p.next # 뒤쪽 노드가 가리키는 곳을 앞의 노드가 참조하게 한다.
                return True
            pp = p        
            p = p.next               # 뒤쪽 노드를 주목
        
        return False                 # 삭제 실패

코드 프로세스

1. 해시 함수를 사용하여 키를 해시값으로 변환합니다.

2. 해시값을 인덱스로 하는 버킷에 주목합니다.

3. 버킷이 참조하는 연결 리스트를 맨 앞부터 차례로 선형 검색합니다. 키와 같은 값이 발견되면 그 노드를 리스트에서 삭제합니다.

그렇지 않으면 삭제에 실패합니다.

삭제를 이해하기 쉽게 하는 이미지 설명

# 한마디로 삭제라는 단어보다 무시라는 단어 즉 참조하는 곳을 바꿔주면서 없애고싶은 원소를 외톨이로 만들어버린다

이렇게 이해하시면 편할 것 같습니다!!!

Django 유저 페이지 구현하기

개발자Dongbaek — Tue, 15 Feb 2022 15:38:01 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django 유저 페이지 구현하기

#insta/urls.py

from django.urls import path, re_path
from django.contrib.auth.validators import UnicodeUsernameValidator

from . import views

# reverse에 사용할 이름
app_name = 'insta'

# 주소에 오는 username이 Unicode 형태인지 확인하는 Validator 
# username_regax = UnicodeUsernameValidator.regex.lstrip('^').strip('$')

urlpatterns = [
    
    path('post/new', views.post_new, name='post_new'),
    path('post/<int:pk>', views.post_detail, name='post_detail'),


    re_path(r'^(?P<username>[\w.@+-]+)/$', views.user_page, name='user_page'),    
    ]

@deconstructible
class UnicodeUsernameValidator(validators.RegexValidator):
    regex = r"^[\w.@+-]+\Z"
    message = _(
        "Enter a valid username. This value may contain only letters, "
        "numbers, and @/./+/-/_ characters."
    )
    flags = 0

https://github.com/django/django/blob/main/django/contrib/auth/validators.py

#UnicodeUsernameValidator은 username이 Unicode 형태의 문자인지 검사하는 Validator입니다.

https://docs.djangoproject.com/en/4.0/ref/contrib/auth/

django.contrib.auth | Django documentation | Django

Django The web framework for perfectionists with deadlines. Overview Download Documentation News Community Code Issues About ♥ Donate

docs.djangoproject.com

#정규 표현식에 익숙해지자!

https://wikidocs.net/4308

07-2 정규 표현식 시작하기

[TOC] ## 정규 표현식의 기초, 메타 문자 정규 표현식에서 사용하는 메타 문자(meta characters)에는 다음과 같은 것이 있다. > ※ 메타 문자란 원래 ...

wikidocs.net

#accounts/forms.py

    # username 중복 방지 함수
    def clean_username(self):
        username = self.cleaned_data.get('username')

        if username:
            qs = User.objects.filter(username='post')
            if qs.exists():
                raise forms.ValidationError("지정할 수 없는 아이디입니다.")
            
            return username

# username이 혹시 다른 url의 이름과 겹치면 오류가 발생하기에 사전에 방지해줍니다.

#insta/views.py

# 유저 페이지
def user_page(request, username):
    page_user = get_object_or_404(get_user_model(), username=username, is_active=True)
    # 해당 유저가 쓴 글만을 filter 처리하여서 저장
    post_list = Post.objects.filter(author=page_user)
    return render(request, "insta/user_page.html", {
        "page_user": page_user,
        "post_list": post_list,
    })

#get_object_or_404의 코드입니다.

def get_object_or_404(klass, *args, **kwargs):
    """
    Use get() to return an object, or raise an Http404 exception if the object
    does not exist.
    klass may be a Model, Manager, or QuerySet object. All other passed
    arguments and keyword arguments are used in the get() query.
    Like with QuerySet.get(), MultipleObjectsReturned is raised if more than
    one object is found.
    """
    queryset = _get_queryset(klass)
    if not hasattr(queryset, "get"):
        klass__name = (
            klass.__name__ if isinstance(klass, type) else klass.__class__.__name__
        )
        raise ValueError(
            "First argument to get_object_or_404() must be a Model, Manager, "
            "or QuerySet, not '%s'." % klass__name
        )
    try:
        return queryset.get(*args, **kwargs)
    except queryset.model.DoesNotExist:
        raise Http404(
            "No %s matches the given query." % queryset.model._meta.object_name
        )

#is_active는 접근이 허용된 사람만 확인하게 해주는 옵션입니다.

#insta/templates/insta/user_page.html

{% extends "insta/layout.html" %}

{% block content %}
    <div class="container">
        <div class="row pt-5 pb-5">
            <div class="col-sm-3" style="text-align: center;">
                <img src="{{ page_user.profile_url }}" class="rounded-circle" style="width: 160px;" />
            </div>
            <div class="col-sm-9">
                {{ page_user.username }}
                <a href="{% url "profile_edit" %}" class="btn btn-secondary btn-sm">
                    Edit Profile
                </a>
                <hr/>
                0 posts, 0 followers, 0 following
                <hr/>
                {{ page_user.name }}
            </div>
        </div>
        <div class="row mt-3">
            {% for post in post_list %}
                <div class="col-sm-4">
                    <img src="{{ post.photo.url }}" alt="{{ post.caption }}" style="width: 100%;%" />
                </div>
            {% endfor %}
        </div>
    </div>

{% endblock %}

Django 포스팅 detail view 구현

개발자Dongbaek — Mon, 14 Feb 2022 17:21:41 +0900

출처 : https://www.inflearn.com/course/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EC%9E%A5%EA%B3%A0-%EC%9B%B9%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

장고(Django)를 배우기 시작한 입문자이시거나, 또는 배우고 싶은 생각이 있으신 분은 위 출처의 강의를 적극 추천드립니다!!!

Django 포스팅 detail view 구현하기

#insta/urls.py

from django.urls import path
from . import views

app_name = 'insta'

urlpatterns = [
    path('post/new', views.post_new, name='post_new'),
    path('post/<int:pk>', views.post_detail, name='post_detail'),
    ]

#insta/views.py

from django.shortcuts import redirect, get_object_or_404


# 포스팅 detail
def post_detail(request, pk):
    # 해당 pk의 포스팅 객체가 없을 경우 404 에러 반환
    post = get_object_or_404(Post, pk=pk)
    return render(request, "insta/post_detail.html", {
        "post" : post,
    })

# 항상 디테일을 구현하면 관련 모델에 get_absolute_url을 지정해주어야한다.

#insta/models.py

class Post(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    photo = models.ImageField(upload_to="insta/post/%Y%m%d")
    # 내용
    caption = models.TextField()
    tag_set = models.ManyToManyField('Tag', blank=True)
    location = models.CharField(max_length=100) 

	# detail view
    def get_absolute_url(self):
        return reverse("insta:post_detail", args=[self.pk])

# 만약 이름으로 접근하게 되면 이름 형태로 반환해주게끔 accounts/models.py에서 설정해준다.

    @property
    def name(self):
        return f"{self.first_name} {self.last_name}"

# 유저가 프로필이 있으면, 유저의 프로필을 보여주고, 없으면 기본 프로필을 보여주는 함수를 accounts/models.py에서 설정해준다.

    # profile이 있는지 검사하고 알맞은 값을 반환하는 로직
    @property
    def profile_url(self):
        if self.profile:
            return self.profile.url
        else:
            return resolve_url('pydenticon_image', self.username)

#insta/templates/insta/post_detail.html

{% extends "insta/layout.html" %}
{% load bootstrap4 %}

{% block content %}
    <div class="container">
        <div class="row">
            <div class="col-sm-12">
                <div class="card">
                    <div class="card-header">    
                        <img src= "{{ user.profile_url }}" style="width: 24px; height: 24px;"/>
                        {{ post.author }}                    
                    </div>
                    <div class="card-body">   
                        {% if post.photo.url %}
                            <img src="{{ post.photo.url  }}" style="width: 100%;"/>
                        {% endif %}                     
                    </div>
                    <div class="card-footer">                           
                        {% for tag in post.tag_set.all %}
                            <span class="badge badge-primary" style="color: #fff;
                            background-color: #007bff;">                        
                                #{{ tag.name }}
                            </span>
                        {% endfor %}                     
                    </div>
                </div>    
            </div>
        </div>
    </div>  
{% endblock %}