심플하고 차분하게

1.  프로젝트 생성 및 요구사항 분석

- 오늘 수업시간에서는 프로젝트 생성 및 요구사항 분석 + 설계 및 기본 구조 개발에 대해서 들었다.

- 각 회사마다 분위기는 다 다르겠지만, 요구사항 분석 시엔 일반적으로 아래의 단계를 거친다고 한다.

  1) 외부 고객 및 내부 고객의 의견에 따라 어떤 사업을 하겠다는 목표가 생기면,

  2) 기획자가 기획안을 만들어 연관됨 팀들과 의견을 나눈 뒤 사용할 기술 및 주요 기능에 대해 보완한다.

  3) 기획자의 기획안을 토대로 개발팀은 개발을 위한 기술 스택 및 구체적인 명세서를 작성한다.

(1) 기술 스택이란 뭔가

- 위 3) 단계에서 "기술 스택"이라함은,

- 어떤 프레임워크와 언어를 쓸 것인가

- 어떤 DB vendor를 쓰고

- 어떤 api를 사용할 것이며

- http 데이터 타입은 어떤 걸 쓸 건지 (ex. xml인지, json인지, yml인지 등)

등 개발을 위한 기본적인 구조를 정하는 걸 말한다.

- 일전에 회사를 다닐 때 적은 설계서를 떠올리면, 주로 기획안 초반에 작성되는 항목들 중 하나였던 걸로 기억한다.

- 기획안에서 간단히 다루어주긴 하겠지만, 내부적으로도 체크가 필요할 것이라 생각된다. 

(2)  구체적인 명세서란

- 기획안을 받으면 개발팀 내부에서도 본격적인 개발에 돌입하기 위해 구체적인 명세서를 작성하기도 한다고 한다.

- 여기서의 구체적인 명세서란, 각 Entity에 대해 이루어지는 작업을 API로 하여 정리한 걸 말하는데

- 검색을 해보니 이건 개발자의 성향에 따라 조금씩 다 다른 것 같았다. (아예 안 쓰는 사람들도 있고)

- 수업에서는 Entity 별로 Http 요청에 대한 처리 API들로 간략히 정리했었다.

- 연습을 한 번 해보고자 동물병원 진료 예약 시스템을 생각해서 하나의 API만 작성해보았다.

2.  기본 구조는 어떻게 잡을 수 있을까

- 기획안에서, 또는 기획안을 받은 후에, 기술 스택에 대해 정하게 되는데, 구체적으로는, 

  코딩 컨벤션이나, 패키지 구조, DB 접속 환경, 연동 API등에 대해 전반적인 틀을 잡는다.

  (이걸 수업시간에선 기본구조를 잡는다고 설명했다.)

- 코딩 컨벤션은 팀 내부에서 사용하는 코딩 스타일을 말한다.

  자주 사용하는 코딩 컨벤션 도구로 ESLint와 Prettier가 있다고 하는데, 자세한 건 바로가기 에서 보면 좋을 것 같다.

- 패키지 구조는 앞서서 이야기했듯 디자인패턴에 따라 달라질 수 있다. 

  (예를들어, 레이어패턴인 경우, N-tier 방식으로 패키지를 만들고, 헥사고날의 경우, 도메인 중심으로 패키지를 만든다.)

  따라서, 회사에서 요구하는 디자인 패턴에 따라 그 패턴을 공부하고 적용하는 게 필요할 것 같다.

3. 명세서에 따라 Entity의 상세정보를 정리하고 개발 시작하기

- 수업에서는 명세서에서 작성한 API 하나에 대해,

- 1) 이미 검토한 정보(HTTP 메소드, 파라미터, 정책, 성공 응답) 와 더불어

  2) 상세 정보 (Entity내에 추가되어야 하는 정보)를 정리 (수업에선, 컬럼명과 데이터타입과 설명까지 정리했다.)

  3) 요청/응답 시 주고받는 데이터 구조까지 정리했다.

- 상당히 도움이 되는 흐름이었는데, 사용자 케이스에 맞춰 요청 API를 먼저 처리하고,

  관련된 객체(Entity)를 만든 후에, 단위 테스트를 하게 되면 개발자도 흐름을 체크하며 개발할 수 있지 않을까 싶다.

[ 참고 및 출처 ]

부트캠프 수업을 들은 후 정리한 내용입니다.

https://mklab-co.medium.com/%EC%9E%91%EC%84%B1%EB%B2%95-%ED%99%94%EB%A9%B4%EC%84%A4%EA%B3%84%EC%84%9C-wireframe-%EC%99%80-%EA%B8%B0%EB%8A%A5%EB%AA%85%EC%84%B8%EC%84%9C-functional-specification-bbcff0071ea2

|  개요

- 수업 시간에 고객의 계좌 정보에 관한 프로그램을 샘플로 만들며 아래의 내용을 배우기로 했다.

- 저작권상 내용을 여기에 담기는 좀 그래서 전반적인 개념에 추가적인 정보를 담아 스스로의 이해를 위해 정리해보려고 한다.

- 강사님의 강의 흐름이 마치 현장 플젝을 해결하는 것 같이 느껴지는데, 이 흐름만 잘 기억해도, 차후 개인 프로젝트를 기획할 때 많은 도움이 될 것 같다.

1. 의존성 추가하기 

- 인텔리j에서 보면, 프로젝트 바로 하위에 "build.gradle"이라는 파일이 있다.

- 앞에서도 잠깐 언급했는데, dependencies 안에 의존성을 추가할 수 있다.

  인텔리j에서 플젝 시작할 때 Lombok이나 JDBC 같은 라이브러리를 추가하면 자동으로 의존성이 추가되는데,

  별도로 직접 작성해줄 수도 있다.

/* 플러그인의 의존성(library) 관리 */
plugins {
	id 'org.springframework.boot' version '2.7.3'
	id 'io.spring.dependency-management' version '1.0.13.RELEASE'
	id 'java'
}

group = 'com.zerobase'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

/* 각종 의존성들(libraries)을 어떤 원격 저장소에서 받을 것인지 지정 */
repositories {
	mavenCentral() // jcenter로 업로드 설정을 간소화할 수 있다.
}

/* 프로젝트 개발에 필요한 의존성들을 선언하는 곳 */
dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

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

2. Lombok

- Lombok은 DTO(=VO) 객체의 Getter/Setter, 생성자를 자동으로 생성해주거나,

  특정 클래스를 지정해서 로그를 자동으로 생성해주는 라이브러리이다.

- 다양한 기능

- Delombok을 통해 Lombok으로 만들어진 생성자 및 메소드 확인하기

  : DTO 객체에서 우측 마우스 - [Delombok]을 누르면 생성자 및 메소드가 자동 생성된다.

- 참고로 @Autowired를 사용해도 생성자나 게터, 필드를 만들 때 의존 객체의 타입을 자동으로 주입해주는데, 

  생성자의 인자가 많이 있거나 수정할 때마다 매번 타이핑을 해야하기 때문에 현재는 사용을 권장하지 않는다. 

  @Autowired 대신 롬복을 사용하는 것이 좋다.

3. HTTP (Hyper Text Tranfer Protocol)

- 하이퍼텍스트란, 링크를 연결시켜주는 텍스트를 말한다. (마치 이것처럼)

- HTTP 프로토콜에 대한 요약 정리

(1) HTTP Request

POST /path HTTP/1.1                   // Header 첫줄 : Method 경로 HTTP버전
Content-Type: application/json        // 받은 콘텐츠 타입
Accept: application/json              // 보낼 콘텐츠 타입 (응답)
UserInfo: {"userId","test1234"}       // 인증키나 회원명 등을 넣는다

{                                     // Body
    "phone" : "010-1234-5678"
}

(2) HTTP Response

HTTP/1.1 200 OK                      // Header 첫줄 : HTTP버전 상태정보 메세지
Content-type: application/json       // content-type부터 연결(keep-alive)유지 기간 등
Transfer-Encoding: chuncked          
Date: Mon, 21 Jun 2022 12:11:23 GMT  
Keep-Alive: timeout=60
Connection: keep-alive

{                                   // Body : 응답 받는 Clinet에게 전달할 데이터
   "message" : "등록 성공"
}

4. H2 DB를 사용하기

(1) H2 DB의 특징 

: 메모리/파일 관계형 DB로, 가볍고 시작할 때마다 자동 삭제-생성 가능하며, 대다수의 DB sql명령어와 호환되어,

: 개발을 하면서 테스트를 하기에 좋은 DB이다.

(2) H2 DB를 설정 - application.yml 로 설정하기

: 스프링 플젝을 처음 생성하면, [src] - [java] - [main] - [resources] 안에 "application.properties" 파일이 있다.

: 애플리케이션에 들어가는 설정들을 정리해서 넣는 파일인데, 이 파일의 확장자를 .properties에서 .yml로 바꾼다.

  rf. .yml파일은 야믈이라고도 하는 yaml 데이터 타입을 말한다. (+ 자세한 내용은 하단의 더보기에)

: 아래의 내용을 보면, 스프링 설정을 야믈 데이터 타입으로 안내하는 것인데 크게 보면,

  [ DB에 대한 설정(위치와 JDBC정보) + H2 콘솔 사용 여부 + JPA 관련 설정(INSERT시작 지점, DB정보, 쿼리 관련 설정) ]

  이렇게 세가지를 아래에서 하고 있는 걸 볼 수 있다.

spring:                                        // spring 플젝의 설정할거다!
  datasource:                                  // (1) DB의 소스 : 
    url: jdbc:h2:mem:test                      // 5가지 정보(url-ip와port와instance),계정,비번)
    username:                                  // -- ip와 port대신 mem (memory를 의미)
    password:
    driverClassName: org.h2.Driver             // JDBC 드라이버 정보
  h2:                                          // (2) h2 console 사용 여부 
    console:
      enabled: true
  jpa:                                         // (3) jpa 관련 설정
    defer-datasource-initialization: true      // table 생성 후로 resource의 data.sql 입력 미룬다(defer)
    database-platform: H2                      // db vendor 
    hibernate:                                 // hibernate (jpa 인터페이스 구현체)
      ddl-auto: create-drop                       // ddl-auto : 자동으로 실행시 drop, create 
    open-in-view: false                        // open-view (뷰에서 볼 것인지)
    properties:                                // properties (설정)
      hibernate:                                 // hibernate - sql 형식으로 쓰고 볼지
        format_sql: true
        show_sql: true

- 설정을 다 하고, 어플리케이션을 이클립스나 인텔리j에서 실행하면, 에디터 콘솔에 Tomcat을 통해 알아서 잘 생성됐다는 메세지가 뜬다.

- 이제, 브라우저에서 아래의 정보를 입력하면 H2 DB 콘솔을 볼 수 있다.

http://localhost:8080/h2-console

- 설정 야믈에 써놓은 URL과 계정명, password를 잘 써주고 연결하면 된다. (JDBC URL이, url이다)

* 처음에 JDBC URL은 jdbc:h2:~/test;로 되어 있는데, 이 부분을 아까 야믈 설정파일에서 설정해두지 않았다면,

  매번 실행할 때마다 주소가 자동 할당되어 에디터 콘솔에 뜨고, 그걸 복사해서 위에 붙여주어야만 한다.

더보기

[ 이름도 귀여운 야믈은 뭘까? ]

 

- 데이터를 전송할 때의 규칙, 약속을 우리는 데이터 타입이라고 한다.

- 데이터 타입에는 XML, JSON 등이 있는데

  - XML은 <>과 들여쓰기로 각 데이터간 관계성을 나타내고

  - JSON은 key와 value로 데이터간의 관계성을 나타낸다면

  - YAML은 - 하이픈을 통해 깔끔하게 데이터간의 관계성을 표현한다.

- 야믈이 귀여운 이름만큼 우리 눈과 마음을 참 깔끔하게 해주는 녀석이라고 기억해두면 좋을 것 같다.

(3) 레이어 디자인 패턴으로 패키징을 하고 JPA를 통해 domain 객체를 만든다.

- 앞서서, 스프링은 MVC 3-tier 아키텍처를 따른다고 했다.

* MVC 3-tier 아키텍처는 SOLID의 SRP원칙(단일책임원칙)을 지키도록 해주는데, 

  [1] 표현층 (Presentation Layer)

  [2] 비즈니스 로직층(Business Logic Layer)

  [3] 데이터 엑세스층(Data Access Layer)

  로 나누어져 있으며, 표현층의 컨트롤러로 비즈니스 로직층으로 넘어간 뒤 DB와 상호작용(Service)하여 처리한다.

- Layered는 n-tier 방식으로 코드를 짜는 디자인 패턴을 말하는 것으로, 각 의존 관계가 마치 레이어처럼 겹겹이 쌓여있다.

  * 실습에서는 controller, service, domain(dto), repository로 나누었는데 아래와 같이 나누어볼 수 있었다.

- 현장에서는 다만, 이와 같은 디자인 패턴 보다는 Hexagonal Architecture 디자인 패턴을 더 선호한다고 한다.

(3-1) 테이블 모델

: 레이어 패턴에서는 dto를 domain안에 만들었는데, @Entity를 통해 이 클래스가 테이블임을 표현한다.

: 이렇게 생성한 후에 다시 애플리케이션을 실행하면, H2 console 부분에 테이블이 생성된 게 보인다.

// import 생략

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder                // 여기까지 Lombok을 사용해 builder, 게터/세터를 만들게 한다.
@Entity                 // Entity를 쓰면 이 클래스를 Entity로 설정하겠다는 의미이다.
public class TableName{

    @Id                 // pk인덱스 생성
    @GeneratedValue     // pk가 Sequence인지, Table인지 등과 세부 제한 설정
    private Long id; 
    
    private String certainMember1;
    
    private String certainMember2;
    
}

(3-2) 리포지토리 만들기

- JPA를 통해 DB와 직접적인 소통을 하는 것은 repository interface이다.

- 중요한 건, 이것은 인터페이스이며 클래스로 만들면 안 된다는 것이다. 

  * 왜 인터페이스로 되어 있을까? 그건 DIP 법칙에 따라 JPA에 너무 의존하지 않게 하려는 것 아닐까? (좀더 생각해보자..)

- JpaRepository<테이블객체명,pk타입>를 구현한 인터페이스를 만든다.

@Repository
public interface CertianRepository extends JpaRepository<TableName, Long> {

}

- JpaRepository의 메소드들은 굉장히 많았는데 그 중에 기본적인 메소드들은 아래와 같았다.

(3-3) 서비스 만들기

- 서비스는 리포지토리 인터페이스를 구현한다.

- 바로 위의 표의 메소드들 (save, findById, delete, count 등)을 호출하는 클래스를 만든다.

@Service
@RequiredArgsConstructor
public class CertainService {
    private final CertainRepository certainRepository; 

    @Transactional
    public void createOneRow() {
        TableName tableName = TableName.builder()
                .memberfield("hahaha")
                .build();
        certainRepository.save(tableName);
    }

    @Transactional
    public TableName getOneRow(Long id) {
        return certainRepository.findById(id).get();
    }
}

(3-4) 컨트롤러로 URI에 대한 HTTP 처리하기

- 앞서서 Client는 브라우저의 URI를 통해 요청을 보낸다고 했다.

- 이제 어느 경로에서 어떻게 URI를 보내면, 특정 서비스의 메소드를 호출할지를 여기서 정해주면 된다.

@RestController
@RequiredArgsConstructor
public class CertainController {
    private final CertainService certainService;

    @GetMapping("/create-certain")
    public String createCertain() {
        certainService.createOneRow();
        return "success";
    }

    @GetMapping("/certain/{id}")
    public Account getAccount(@PathVariable Long id) {
        return certainService.getOneRow(id);
    }
}

5. 트랜잭션

트랜잭션 : 데이터베이스의 상태를 변경시키기 위해 수행하는 작업단위

[출처] 코딩팩토리, https://wonit.tistory.com/462

- 트랜잭션은 DB의 상태를 변경시키는 것으로, CRUD(INSERT, SELECT, UPDATE, DELETE) 행위를 말한다.

(1) Commit과 Rollback

- 트랜잭션은 순차적으로 Commit -저장-을 하며 실패해도 로그를 남겨, 앞의 트랜잭션이 다 끝나야 실제로 반영한다.

- 만약에, 트랜잭션이 비정상적으로 종료한다면 Rollback -철회-을 통해, 트랜잭션 전체 또는 부분적으로 결과를 취소한다.

(2) 트랜잭션의 상태

- 트랜잭션은 실행중(Active)이거나

  - 커밋 일부 완료(Partially Commited), 커밋 모두 완료(Commited)

  - 실행중 오류 발생으로 실패(Failed), 비정상적 종료로 rollback 수행(Aborted)

- 하는 총 5가지의 상태를 가질 수 있다.

(3) 트랜잭션의 특징

- 트랜잭션에는 4가지의 특징이 존재하는데,

6. Embedded Redis 실행

레디스는 고성능 In-Memory 키-값 저장소로서 
문자열, 리스트, 해시, 셋, 정렬된 셋 형식의 데이터를 지원하는 NoSQL이다.

[출처] https://devlog-wjdrbs96.tistory.com/374

- 위의 말을 풀어서 이해했을 때, 레디스는 결국 DB의 데이터를 휘발적으로 메모리에 직접 넣어서 빠르게 처리할 수 있게 해주는 녀석이며, 데이터의 모양은 noSql 중에서도 키-값 형태로 저장되는 녀석인 것 같다.

+ noSql에 대해 더 알고 싶다면 아래의 더보기로

- Redis는 SpinLock을 통해 동시성 제어를 해주며, AOP를 실습할 때에 따라서 자주 사용된다고 한다.

- 나의 경우에는 수업에 따라 인텔리j를 쓰고 있어서 별도로 Redis를 설치하는 곤욕을 겪지 않았는데, 따로 설치해주는 경우도 있는 모양이다. 그게 필요한 경우에 잘 나와 있는 페이지가 있어서 갖고 왔다. 

https://inpa.tistory.com/entry/REDIS-%F0%9F%93%9A-Window10-%ED%99%98%EA%B2%BD%EC%97%90-Redis-%EC%84%A4%EC%B9%98%ED%95%98%EA%B8%B0

(1) Redis를 dependencies에 추가 & application.yml에도 host/port를 설정해준다.

- Redis도 라이브러리이기 때문에 쓰려면 의존성을 추가해주어야 한다.

- Build.gradle에 들어가서, 아래와 같이 dependencies를 작성해 주었다.

- 아래에서 exclude된 부분은 이미 롬복에서 처리해주는 부분이기 때문에, 제외하지 않으면 오류가 난다고.

  그래서 이렇게 제외를 해주는 게 좋다고 한다..

dependencies {
	// redis client
	implementation 'org.redisson:redisson:3.17.1'
	// embedded redis
	implementation('it.ozimov:embedded-redis:0.7.3') {
		exclude group: "org.slf4j", module: "slf4j-simple"
	}
}

- Redis 또한 in-memory 방식의 noSql이기 때문에 다른 DB들과 마찬가지로 host와 port가 필요하다.

- 앞에서 만들어주었던 application. 야믈파일에서 아래와 같이 호스트와 계정을 넣어준다.

  * 보통 Redis는 6379 포트를 쓴다고 한다.

spring:
  redis:
    host: 127.0.0.1
    port: 6379

(2) LocalRedis 실행 설정하기

- Config 클래스를 하나 만들어, 포트정보를 통해 RedisServer를 만들어준다.

- RedisServer는 @PostConstruct와 @PreDestroy를 할 수 있는 메소드를 생성해주는데,

  Bean의 생성주기에서 빈 생성 및 의존관계 주입 후 @PostConstruct가 이루어지고, 종료 전에 @PreDestroy가 이루어진다.

[  Bean의 생성주기 ]

@Configuration
public class LocalRedisConfig {
    @Value("${spring.redis.port}")
    private int redisPort;
    private RedisServer redisServer;

    @PostConstruct
    public void startRedis() {
        redisServer = new RedisServer(redisPort);
        redisServer.start();
    }

    @PreDestroy
    public void stopRedis() {
        if (redisServer != null) {
            redisServer.stop();
        }
    }
}

(3) LocalRepository 등록

- Config 클래스를 하나 만든 후에, 호스트와 포트 맴버 필드를 만들고, RedisClient를 호출하는 메소드를 만든다. 

- 이 설정 자체도 너무 어려웠다..  암기가 필요한 순간.

@Configuration
public class RedisRepositoryConfig {
    @Value("${spring.redis.host}")    // EL같다. application의 데이터를 가져온다.
    private String redisHost;

    @Value("${spring.redis.port}")    // EL같다. application의 데이터를 가져온다.
    public int redisPort;

    @Bean
    public RedissonClient redissonClient() {  // RedissonClient을 반환해주어야한다.
        Config config = new Config();  // Config 객체 생성
        config.useSingleServer().setAddress("redis://" + redisHost + ":" + redisPort);

        return Redisson.create(config);
    }
}

7. 테스트

- 과거의 경우 어떤 서비스가 만들어지면 그것을 하나하나 검수하는 과정을 거쳤었다.

- 현재에는 자동화된 테스트 코드를 통해 빠르게 테스트를 하고 있다. 

- 다양한 테스트 커버리지와 테스트 방법론이 존재한다.

[ 테스트에 관한 개념 ]

(1) 테스트 커버리지 : 단위 테스트 / 전 구간 테스트 / 통합 테스트

(2) TDD란 뭘까? Test-Driven-Development의 약자로, "테스트 주도 개발"이라는 테스트 방법론을 의미한다.

  : 간단히 요약하자면, 개발 전에 테스트 코드부터 작성하고 개발 후 리팩토링(수정)하는 방법이다.

(3) 테스트는 왜 해야할까? 비즈니스 로직에 맞고, 빠르고 안정적인 개발을 하기 위함

(4) 테스트를 잘 하기 위해서는 뭘 해야할까?

[ 테스트를 위한 라이브러리 - JUnit, Mockito ]

[ JUnit5와 Mockito를 통한 단위 테스트 실습 ]

(1) JUnit5를 사용해보기

(1-1) build.gradle의 dependencies에 "spring-boot-starter-test"가 있는지 확인 (디폴트로 되어있다)

dependencies {
	// 생략
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

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

- 위에 보면 tasks.named('test')가 있는데, 'test'로 된 디렉토리의 테스트들을 JUnit으로 돌리겠다는 의미이다.

(1-2) 테스트하고자 하는 클래스에서 Ctrl+shirt+T로 테스트를 생성한다

- 보면 아래처럼 JUnit5로 라이브러리가 설정되어 있는 걸 볼 수 있다. 이걸 4로 바꾸면 당연히 테스트는 안 된다.

(1-3) @SpringBootTest와 @Autowired를 통해 의존을 주입한다.

// import 생략

@SpringBootTest      // 실제 환경과 동일하게 모든 Bean들을 등록
class CertainTest{
	
    @AutoWired // 주입
    CertainService certainService;
    
    @BeforeEach // 아래의 두 메소드 각각 시작 전에 행 하나 생성
    void init() { certainService.createOneRow(); }
    
    @Test
    @DisplayName("Test Name blah blah")
    void testGetOneRow(){
    	TableName tableName = certainService.getOneRow(1L);
        assertEquals("010-1234-5678", tableName.getPhone());
        assertEqauls(TableName.CertainType, tableName.getType());
    }
    
    
    @Test
    @DisplayName("Test Name blah blah2")
    void testGetOneRow2(){
    	TableName tableName = certainService.getOneRow(2L);
        assertEquals("010-1234-5678", tableName.getPhone());
        assertEqauls(TableName.CertainType, tableName.getType());
    }
}

- 그런데 위와 같이 하면 @SpringBootTest로 안 쓰는 클래스까지 가져오면 원하던 테스트에서 방향이 달라질 수 있다.

- 더불어 매번 @AutoWired로 주입을 하게되면 너무 품이 많이 든다.

- 이를 해소하고자 Mockito의 Mock을 사용한다.

(2) Mockito의 Mock을 사용해서 service에서 필요한 클래스만 가짜로 주입하기

@ExtendWith(MockitoExtension.class)   // MockitoExtension이라는 클래스를 쓴다.
class CertainServiceTest {

    @Mock // 가짜 생성
    private CertainRepository certainRepository;

    @InjectMocks // 위에서 만든 Mock을 주입
    private CertainService certainService;

    @Test
    @DisplayName("성공")
    void testXXX() {

        // given
        given(certainRepository.findById(anyLong()))
                .willReturn(Optional.of(TableName.builder()
                        .type(TableNameType.TYPE)
                        .phone("010-1234-5678").build()));

        // when
        TableName tableName = certainService.getOneRow(1234L);

        // then
        assertEquals("010-1234-5678", certainService.getPhone());
        assertEquals(TableNameType.TYPE, certainService.TableNameType());
    }
}

[ Controller 테스트 하기 ]

@WebMvcTest(AccountController.class)
class AccountControllerTest {
    @MockBean
    private AccountService accountService;

    @MockBean
    private RedisTestService redisTestService;

    @Autowired
    private MockMvc mockMvc;

    @Test
    void successGetAccount() throws Exception{
        // given
        given(accountService.getAccount(anyLong()))
                .willReturn(Account.builder()
                        .accountNumber("3456")
                        .accountStatus(AccountStatus.IN_USE)
                        .build());
        // when
        // then
        mockMvc.perform(get("/account/876"))
                .andDo(print())
                .andExpect(jsonPath("$.accountNumber").value("3456"))
                .andExpect(jsonPath("$.accountStatus").value("IN_USE"))
                .andExpect(status().isOk());
    }
}

[ Service 테스트의 다양한 방법 ]

verify
의존하고 있는 Mock이 해당되는 동작을 수행했는지 확인하는 검증

verify(accountRepository, times(1)).save(any<Account>());
verify(accountRepository, times(0)).findById(anyLong());

ArgumentCaptor
의존하고 있는 Mock에 전달된 데이터가 내가 의도하는 데이터가 맞는지 검증

ArgumentCaptor<Account> captor = ArgumentCaptor.forClass(Account.class);
verify(accountRepository, times(1)).save(captor.capture());
assertEquals("1234", captor.getValue().getAccountNumber());

assertions
다양한 단언(assertion) 방법들

assertEquals("1234", captor.getValue().getAccountNumber());
assertNotEquals("1234", captor.getValue().getAccountNumber());
assertNull(result);
assertNotNull(result);
assertTrue(resut.getBoolean());
assertFalse(resut.getBoolean());
assertAll(
() -> assertTrue(resut.getBoolean()),
() -> assertFalse(resut.getBoolean())
);

assertThrows
예외를 던지는 로직을 테스트하는 방법

AccountException exception =
assertThrows(AccountException.class, () ->
accountService.getAccount(123L));
assertEquals(ACCOUNT_NOT_FOUND, exception.getErrorCode());

[ 참조 및 출처 ]

부트캠프 수업 후 정리한 내용입니다.

HTTP 메시지 https://developer.mozilla.org/ko/docs/Web/HTTP/Messages

HTTP 2.0  https://velog.io/@taesunny/HTTP2HTTP-2.0-%EC%A0%95%EB%A6%AC

Lombok을 이용해 Builder 패턴 만들기 https://zorba91.tistory.com/298

H2 DB의 특징 https://jamie95.tistory.com/188

야믈 yaml 파일이란 https://www.inflearn.com/questions/16184

JPA란? https://dbjh.tistory.com/77?category=853400 

Layer 디자인 패턴 https://4ngeunlee.tistory.com/222

트랜잭션이란? https://wonit.tistory.com/462

Bean 생성주기 https://velog.io/@zenon8485/%EC%8A%A4%ED%94%84%EB%A7%81-%EA%B8%B0%EB%B3%B8-%EC%9B%90%EB%A6%AC-4.-%EC%8A%A4%ED%94%84%EB%A7%81-Bean%EC%9D%98-%EC%83%9D%EB%AA%85%EC%A3%BC%EA%B8%B0

단위테스트/통합테스트/인수테스트 https://tecoble.techcourse.co.kr/post/2021-05-25-unit-test-vs-integration-test-vs-acceptance-test/

TDD란? http://clipsoft.co.kr/wp/blog/tddtest-driven-development-%EB%B0%A9%EB%B2%95%EB%A1%A0/

|  예외처리

- 예외 : 프로그램이 예상하지 못한 상황을 만났을 때 오류를 처리하는 것

- 자바에서는 try-catch문 안에서 예외처리를 했었다.

try {
	// 행동
} catch (Exception e) {
	log.error("cetian exception");
}

- 스프링에서는 이러한 예외처리를 간편하게 할 수 있도록 하였다.

|  스프링의 예외처리 (REST API)

- 과거와는 달리 오늘날에는 프론트엔드와 백엔드 분업화가 잘 이루어져 있다.

- 백엔드에서는 보통 Rest API를 사용해 컨트롤러 기반의 예외처리를 주로 한다.

- 현장에서 예외처리를 할 때에는 enum과 예외객체를 통해 custom exception을 만들고,

 @RestControllerAdvice를 사용해서 예외처리를 한다.

[ Rest API를 활용한 컨트롤러 기반 예외 처리 ]

(1) @ExceptionHandler

- 컨트롤러에 예외 발생 시, 이를 처리해주는 메소드를 만들고 @ExceptionHandler를 표시

- 리스트 방식으로 @ExceptionHandler(IllegalAccessException e1, CustomeException e2) 넣을 수도 있다.

(2) HTTP Status code 변경 

(3) 예외처리 우선순위

- 1. 해당 Exception이 정확히 지정된 Handler

- 2. 해당 Exception의 부모 예외 Handler

- 3. 또는 모든 예외의 부모 Exception

[ 어플리케이션의 전역적 예외 처리 - @RestControllerAdvice ]

- 방대한 양의 컨트롤러가 있는 프로그램에서 예외처리를 어떻게 해야할까?

- @RestControllerAdvice  :  Controller에게 사용되는 일종의 조언

  - 기존의 ControllerAdvice는 view를 응답하는 방식이었다면,

  - ResotControllerAdvice는 REST API용으로 객체를 응답하는 방식이다. (주로 JSON)

- 현재 개발자들에게 가장 많이 사용되고 있는 방식이라고 한다.

|  예외처리 실습

[1] Controller에 @ExceptionHandler로 예외처리 메소드를 만든다.

@ExceptionHandler(IllegalAccessException.class)
public String handleIllegalAccessException(
        IllegalAccessException e){

    log.error("IllegalAccessException is occured.", e);

    return "INVALID_ACCESS";
}

>> 동일 Controller 클래스 내 HTTP 매핑 메소드

@GetMapping("/order/{orderId}")
public String getOrder(
        @PathVariable("orderId") String orderId,
        @RequestParam("orderAmount") Integer orderAmount) throws IllegalAccessException {

    log.info("Get some order");

    if ("500".equals(orderId)) {
        throw new IllegalAccessException("500 is not valid orderId");
    }

    return "OrderId : " + orderId + ",  orderAmount : " + orderAmount;
}

>> 요청 및 응답

http://localhost:8080/order/500?orderAmount=10000

HTTP/1.1 200 
Content-Type: text/plain;charset=UTF-8
Content-Length: 14
Date: Sun, 11 Sep 2022 01:24:40 GMT
Keep-Alive: timeout=60
Connection: keep-alive

INVALID_ACCESS

[2] @ResponsStatus로 HTTP 상태 코드를 설정한다.

- 참고 : HTTP 상태 코드 의미

- 위를 보면 현재 페이지는 정상(HTTP/1.1 200)으로 나타나는데, 이를 변경하고 싶을 때 @ResponseStatus를 쓴다

@ResponseStatus(HttpStatus.FORBIDDEN)
@ExceptionHandler(IllegalAccessException.class)
public String handleIllegalAccessException(
        IllegalAccessException e){

    log.error("IllegalAccessException is occured.", e);

    return "INVALID_ACCESS";
}

>> 요청 및 응답

http://localhost:8080/order/500?orderAmount=10000

HTTP/1.1 403 
Content-Type: text/plain;charset=UTF-8
Content-Length: 14
Date: Sun, 11 Sep 2022 01:30:49 GMT
Keep-Alive: timeout=60
Connection: keep-alive

INVALID_ACCESS

[3] 예외객체를 만들어 JSON방식으로 예외 데이터를 전달한다.

- lombok을 활용하여 dto 안에 예외처리 객체를 만든다.

package com.example.websample.dto;

import lombok.AllArgsConstructor;
import lombok.Data;

@AllArgsConstructor
@Data
public class ErrorResponse {
    private String errorCode;
    private String message;
}

- 위에서 작성했던 예외처리 코드를 변경하여 객체로 묶는다.

@ResponseStatus(HttpStatus.FORBIDDEN)
@ExceptionHandler(IllegalAccessException.class)
public ErrorResponse handleIllegalAccessException(
        IllegalAccessException e){

    log.error("IllegalAccessException is occured.", e);

    return new ErrorResponse("INVALID_ACCESS",
            "IllegalAccessException is occured.");
}

>> 요청 및 응답

http://localhost:8080/order/500?orderAmount=10000

HTTP/1.1 403 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sun, 11 Sep 2022 01:37:26 GMT
Keep-Alive: timeout=60
Connection: keep-alive

{
  "errorCode": "INVALID_ACCESS",
  "message": "IllegalAccessException is occured."
}
Response file saved.
> 2022-09-11T103726.403.json

Response code: 403; Time: 513ms (513 ms); Content length: 77 bytes (77 B)

[4] ResponseEntinty를 사용하면 response에 헤더를 담을 수 있고, responseStatus를 지정할 수 있다.

@ExceptionHandler(IllegalAccessException.class)
public ResponseEntity<ErrorResponse> handleIllegalAccessException(
        IllegalAccessException e){

    log.error("IllegalAccessException is occured.", e);

    return ResponseEntity
            .status(HttpStatus.FORBIDDEN)
            .header("newHeader", "some value")
            .body(new ErrorResponse("INVALID_ACCESS",
                    "IllegalAccessException is occured."));
}

[5] 커스텀 예외처리 : enum과 예외객체를 사용하는 별도의 Custom Exception 클래스를 만든다.

- exception > ErrorCode (Enum)

package com.example.websample.exception;

public enum ErrorCode {
    TOO_BIG_ID_ERROR,
    TOO_SMALL_ID_ERROR
}

- dto > ErrorResponse (예외객체)

package com.example.websample.dto;

import com.example.websample.exception.ErrorCode;
import lombok.AllArgsConstructor;
import lombok.Data;

@AllArgsConstructor
@Data
public class ErrorResponse {
    private ErrorCode errorCode;
    private String message;
}

- exception > WebSampleException (예외처리 클래스)

package com.example.websample.exception;

import lombok.AllArgsConstructor;
import lombok.Data;

@AllArgsConstructor  // constructor
@Data                // getter/setter
public class WebSampleException extends RuntimeException{
    private ErrorCode errorCode;
    private String message;
}

>> 컨트롤러

@GetMapping("/order/{orderId}")
public String getOrder(
        @PathVariable("orderId") String orderId,
        @RequestParam("orderAmount") Integer orderAmount) throws WebSampleException {

    log.info("Get some order");

    if ("500".equals(orderId)) {
        throw new WebSampleException(
                ErrorCode.TOO_BIG_ID_ERROR,
                "500 is too big orderId");
    }

    if ("3".equals(orderId)) {
        throw new WebSampleException(
                ErrorCode.TOO_SMALL_ID_ERROR,
                "3 is too small orderId"
        );
    }

    return "OrderId : " + orderId + ",  orderAmount : " + orderAmount;
}

@ExceptionHandler(WebSampleException.class)
public ResponseEntity<ErrorResponse> handleWebSampleException(
        WebSampleException e){

    log.error("WebSampleException is occured.", e);

    return ResponseEntity
            .status(HttpStatus.INSUFFICIENT_STORAGE)
            .body(new ErrorResponse(ErrorCode.TOO_BIG_ID_ERROR,
                    "WebSampleException is occured."));
}

[6] @RestControllerAdvice 를 넣은 별도의 예외처리 클래스를 만든다.

- 사용법은 간단하다. 클래스에 @RestControllerAdvice를 넣고, 예외처리 핸들러 메소드를 모두 가져오면 된다.

- 각 컨트롤러는 지정한 예외(ex.WebSampleException)에 맞는 ExceptionHandler를 찾는다.

- 만약 없다면, 자신의 부모 예외를 찾고, 그도 없을 시에는 Exception을 찾아간다.

package com.example.websample.exception;

import com.example.websample.dto.ErrorResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalAccessException.class)
    public ResponseEntity<ErrorResponse> handleIllegalAccessException(
            IllegalAccessException e){

        log.error("IllegalAccessException is occured.", e);

        return ResponseEntity
                .status(HttpStatus.FORBIDDEN)
                .body(new ErrorResponse(ErrorCode.TOO_BIG_ID_ERROR,
                        "IllegalAccessException is occured."));
    }

    @ExceptionHandler(WebSampleException.class)
    public ResponseEntity<ErrorResponse> handleWebSampleException(
            WebSampleException e){

        log.error("WebSampleException is occured.", e);

        return ResponseEntity
                .status(HttpStatus.INSUFFICIENT_STORAGE)
                .body(new ErrorResponse(ErrorCode.TOO_BIG_ID_ERROR,
                        "WebSampleException is occured."));
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleWebSampleException(
            Exception e){

        log.error("WebSampleException is occured.", e);

        return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new ErrorResponse(ErrorCode.TOO_BIG_ID_ERROR,
                        "Exception is occured."));
    }
}

|  정리

[ 참고 및 출처 ]

- 부트캠프 수업을 들은 후 정리

- Http 응답 코드 https://namu.wiki/w/HTTP/%EC%9D%91%EB%8B%B5%20%EC%BD%94%EB%93%9C

|  MVC 구조로 보는 필터와 인터셉터

- 요청사항에 대해 필터와 인터셉터를 거친다 

- 사용되는 메소드의 전반적인 흐름

- 필터와 인터셉터와 AOP

|  필터 실습

[1] config 패키지 안에 Filter 클래스를 만든다.

- Filter 클래스는 Filter 인터페이스를 구현하여 만들면 된다.

- Filter 클래스를 만들 때엔 doFilter() 메소드에서 chain.doFilter()를 꼭 해주어야 같은 필터로 인식한다.

// import는 생략

@Slf4j
public class LogFilter implements Filter{
	
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
                         throws IOException, ServletException {
        // 외부 -> filter (-> 처리 ->) filter -> 외부
        log.info("Hello LogFilter : " + Thread.currentThread());
        chain.doFilter(request, response); // chain.doFilter()는 꼭 필요
        log.info("Bye LogFilter : " + Thread.currentThread());
    }
}

[2] Filter 클래스를 구현할 때 방법 두가지

(1) @Component로 Filter 클래스를 스캐너가 자동 스캔할 수 있도록 하기

// import는 생략

@Slf4j
@Component
public class LogFilter implements Filter{
	
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
                         throws IOException, ServletException {
        // 외부 -> filter (-> 처리 ->) filter -> 외부
        log.info("Hello LogFilter : " + Thread.currentThread());
        chain.doFilter(request, response); // chain.doFilter()는 꼭 필요
        log.info("Bye LogFilter : " + Thread.currentThread());
    }
}

(2) 별도의 DI 설정 클래스에서 Filter클래스를 Bean으로 등록하기

- 위의 Filter 클래스에서 @Component는 생략한다.

- FilterRegistrationBean<Filter> 클래스를 통해 필터를 등록한다.

- FilterRegistrationBean의 메소드들

package com.example.websample.config;

// import 생략

@Configuration
public class WebConfig{
	
    @Bean
    public FilterRegistrationBean logginFilter(){
    	
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        
        filterRegistrationBean.setFilter(new LogFilter());
        filterRegistrationBean.setOrder(1);
        filterRegistrationBean.addUrlPatterns("/*");
        
        return filterRegistrationBean;
    }
}

>> 기존에 컨트롤러는 아래의 것을 사용하고, 실행해보면

@GetMapping("/order/{orderId}")
public String getOrder(
        @PathVariable("orderId") String orderId,
        @RequestParam("orderAmount") Integer orderAmount)
{
    log.info("Get some order");
    return "OrderId : "+ orderId +",  orderAmount : " +  orderAmount;
}

>> 요청

http://localhost:8080/order/252?orderAmount=1000

>> 응답

OrderId : 252, orderAmount : 1000

>> 로그

com.example.websample.config.LogFilter   : Hello LogFilter : Thread[http-nio-8080-exec-1,5,main]
com.example.websample.config.LogFilter   : Bye LogFilter : Thread[http-nio-8080-exec-1,5,main]
c.e.w.controller.SampleController        : Get some order

|  인터셉터 실습

- 일반적으로 Filter로는 간단한 해킹 방지 코드를 작성하고, 인터셉터를 활용해서 세부적인 공통코드를 작성한다.

-  preHandle, postHandle(응답 성공), afterCompletion(항상)

[1] 인터셉터는 HandlerInterceptor 인터페이스를 구현하여 만들 수 있다.

packages com.exmaple.websample.config;

// import 생략

@Slf4j
public class LogInterceptor implements HandlerInterceptor{
	
}

[2] 인터셉터는 세가지의 메소드를 구현해야하는데, 각각의 특징은 아래와 같다.

packages com.exmaple.websample.config;

// import 생략

@Slf4j
public class LogInterceptor implements HandlerInterceptor{
	@Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        log.info("preHandle LogInterceptor: " + Thread.currentThread());
        log.info("preHandle handler: " + handler);

        return true; // 이 다음 인터셉터가 진행되길 바라면 true, 아니면 false
    }

    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {

        log.info("postHandle LogInterceptor: " + Thread.currentThread());
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                Exception ex) throws Exception {
        log.info("afterHandle LogInterceptor: " + Thread.currentThread());

        if (ex != null) {
            log.error("afterCompletion exception : " + ex.getMessage());
        }

    }
}

[3] @Configuration 클래스에서 WebMvcConfigurer를 구현하고, addInterceptors()를 통해 인터셉터를 추가한다.

- WebMvcConfigurer의 addInterceptors()는 InterceptorResgistration을 반환한다.

- 내부적으로 아래와 같은 메소드들이 있는데 이들 모두 InterceptorResgistration을 반환하므로 메소드 체이닝을 한다.

- 메소드들

package com.example.websample.config;

// import 생략

@Configuration
public class WebConfig implements WebMvcConfigurer{
	
    // Filter 내용 생략
    
    // Interceptor 내용
    @Override
    public void addInterceptors(InterceptorRegistry registry){
    	// registry : 등록 내용 관리부
        registry.addInterceptor(new LogInterceptor())
                .order(1)
                .addPathPatterns("/**")
                .excludePathPatterns("/css/*", "/images/*");
    }
}

>> 기존의 컨트롤러에 예외 사항을 임의로 추가

@GetMapping("/order/{orderId}")
public String getOrder(
        @PathVariable("orderId") String orderId,
        @RequestParam("orderAmount") Integer orderAmount) throws IllegalAccessException {

    log.info("Get some order");

    if ("500".equals(orderId)) {
        throw new IllegalAccessException("500 is not valid orderId");
    }

    return "OrderId : " + orderId + ",  orderAmount : " + orderAmount;
}

>> 요청

http://localhost:8080/order/500?orderAmount=1000

>> 로그

// 필터 진입
Hello LogFilter : Thread[http-nio-8080-exec-1,5,main]

// preInterceptor
preHandle LogInterceptor: Thread[http-nio-8080-exec-1,5,main]
preHandle handler: com.example.websample.controller.SampleController#getOrder(String, Integer)

// handler
Get some order

// ! postInterceptor로 가지 않았다.

// afterInterceptor
afterHandle LogInterceptor: Thread[http-nio-8080-exec-1,5,main]
afterCompletion exception : 500 is not valid orderId

// exception 메세지 - 오류 코드 나머지는 생략
Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.IllegalAccessException: 500 is not valid orderId] with root cause
java.lang.IllegalAccessException: 500 is not valid orderId

// 브라우저에 페이지 로딩하며 다시 실행
preHandle LogInterceptor: Thread[http-nio-8080-exec-1,5,main]
preHandle handler: org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController#errorHtml(HttpServletRequest, HttpServletResponse)
postHandle LogInterceptor: Thread[http-nio-8080-exec-1,5,main]
afterHandle LogInterceptor: Thread[http-nio-8080-exec-1,5,main]

|  정리

[ 참조 및 출처 ]

부트캠프 수업 후 내용 정리

서블릿의 생명주기 https://kadosholy.tistory.com/47

[Spring] Interceptor, filter, AOP의 차이|작성자 심해펭귄

|  MVC

- MVC란? Model + View + Controller 의 약자를 말하며,

- 스프링은 내부적으로 Dispatcher가 있어, 어떤 요청이 있을 때마다 적절한 컨트롤러를 찾아 매핑한다고 했다.

- 이때 말하는 요청이란, 사용자가 보내는 HTTP 요청을 말하며 오늘날 웹 환경은 일반적으로 REST 방식을 따른다.

- REST는 URI의 자원에 고유한 이름-표현(ex. name, userId)-을 주어 자원의 상태 정보를 주고 받는 것으로,

  GET/POST/PUT/DELETE와 더불어 ?파라미터명=값 과 같이 자신만의 규칙을 갖고 있다.

- 스프링에서는 HTTP 요청을 해석하기 위해 RestController를 사용하며, 해당 컨트롤러의 메소드와 매핑하기 위해,

  RequestMapping 또는 축약형 Mapping (ex.@GetMapping)을 사용한다.

- HTTP의 패킷은 다른 프로토콜과 마찬가지로 Header와 Body를 가지고 있는데, 일반적으로 DB에 데이터를 추가하거나 수정할 때에는 이때 말하는 RequestHeader와 RequestBody를 통해 데이터를 읽고 소통한다.

더보기

- Spring MVC의 흐름

[1] Dispatcher Servlet이 요청 URL을 받아 HandlerMapping에 전달  * Dispatch : 파견 보내다.  rf. 도서관의 사서(dispatcher)는 도서를 요청(request)받았고, 도서 코드 목록(HalderMapping)서 도서를 어떻게 찾을지 본다. [2] HandlerMapping는 요청 URL에 맞는 Controller와 Method 정보를 반환 rf. 도서의 코드 목록에 따르면 해당 도서는 '역사' 카테고리 구역에 있단다. [3] Dispatcher Servlet이 Handler Adapter에게 요청 처리를 위임   rf. 사서는 인턴에게 '역사' 카테고리 책장으로 이동해서, 가나다순으로 진열된 책들을 보면 된다고 알려준다. [4] HandlerAdapter가 Controller와 Method를 실행 rf. 인턴이 찾으려는 도서의 코드와, 사서의 안내를 가지고 '역사' 구역에 가서 도서를 찾는다. [5] Cotroller는 비즈니스 로직을 처리하고, 그 결과를 바탕으로 뷰(ex.JSP)에 전달할 객체를 Model 객체에 저장 rf. 인턴은 찾은 도서를 가져와 책수레에 담는다. [6] Dispatcher Servlet은 view name을 View Resolver에 전달하여 View 객체를 얻음 rf. 사서는 인턴으로부터 "00책 가져왔어?"라고 물어보고, 인턴은 "00책 여기있어요."하고 책수레에 있던 도서를 전달한다. [7] Dispatcher Servlet은 View 객체에 화면 표시를 의뢰 rf. 사서는 책을 요청한 사람에게 책을 전달하기 위해 "00책 요청하신분~?"하고 물어본다.  [8] View 객체는 해당하는 뷰(ex.JSP.Thymeleaf)를 호출하며,     뷰는 Model 객체에서 화면 표시에 필요한 객체를 가져와 화면 표시를 처리 rf. 사서는 책을 요청한 사람에게 책을 대여해주고, 반납일에 대해 안내한다.

|  HTTP 요청 - RestController

- HTTP 요청 및 응답은 Rest 방식에 따른다.

- 데이터 타입은 일반적으로 JSON 타입을 많이 사용한다. (XML보다 경량)

- Controller와 RestController의 차이

- 웹을 통해서 받는 URI의 경우 아래와 같이 [URL + 전달하려는 데이터]로 구성되어 있다.

URI 예시 
https://why-dev.tistory.com/252?category=964854

- RestController를 만들어주기 위해서는 아래와 같이 @RestController를 작성해주어야 한다.

@RestController
public class SampleController{

}

+ 여기에 만약에 롬복을 추가할 경우,

@Slf4j
@RestController
public class SampleController{

}

|  HTTP 요청 매핑

[1] Mapping Annotation

- 요청방식을 직접 지정 (GET,POST...)

// GET, POST 등의 요청방식을 직접 지정
@RequestMapping(value = "/page/252", method = RequestMethod.GET)
public String getPage(){
    log.info("Get some page information");
    return "page:252"; // JSON 방식
}

+ RequestMethod는 enum이다.

public enum RequestMethod {

   GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE

}

[2] 축약형 Mapping Annotation

- 최근에는 Mapping Annotation보다 축약형을 많이 사용한다.

- 아래와 같이 각 타입에 맞게 Annotation을 넣어주면 된다.

@GetMapping("/page/252") 
public String getPage(){
    log.info("Get some page");
    return "pageId : 252";
}

@PostMapping("/page")
public String createPage(){
    return "page created -> pageId : 252";
}

- 만약에 HTTP 전송에 대한 테스트를 하고 싶다면, 아래의 툴들을 이용할 수 있다.

|  HTTP 요청 파라미터 전송

[1] Get과 Delete - @PathVariable, @RequestParam

(1) PathVariable : id를 path에 넣어 받는다

- 여기서의 id는 주문 번호(order id)와 같이 고유한 id 값을 의미한다.

- @PathVariable

@GetMapping("/{pageId}")
public String getCategory(@PathVariable("pageId") String pageId) {
    log.info("Get some page");
    return "pageId : " + pageId;
}

(2) query-params : 추가적인 정보들을 입력한다.

- @RequestParam

- 주로 게시판의 검색 필터 페이징에서 많이 사용한다.

- 만약에 추가적으로 필수사항이나 디폴트 옵션을 주고 싶다면 아래 키워드를 넣어줄 수도 있다.

@GetMapping("/{pageId}")
public String getPage(@PathVariable("pageId") String pageId,
                          @RequestParam("category") String category) {
    log.info("Get some page");
    return "pageId : " + pageId + ", category : " + category;
}

>> 요청

// 요청
GET http://localhost:8080/252?category=964854
Content-Type: application/json

>> 응답

// 응답
HTTP/1.1 200 
Content-Type: text/plain;charset=UTF-8
Content-Length: 31
Date: Sat, 10 Sep 2022 17:58:31 GMT
Keep-Alive: timeout=60
Connection: keep-alive

pageId : 252, category : 964854

- Delete도 Get과 마찬가지로 PageVariable을 쓸 수 있다.

@DeleteMapping("{pageId}")
public String deletePage(@PathVariable String pageId){
    log.info("Delete some page");
    return "deleteId : " + pageId;
}

@GetMapping("/{pageId}")
public String getPage(@PathVariable(value = "pageId") String pageId,
                      @RequestParam(value = "category", required = false) String category) {
    log.info("Get some page");
    return "pageId : " + pageId + ", category : " + category;
}

GET http://localhost:8080/252
Content-Type: application/json

pageId : 252, category : null

[2] Post, Put, Patch - @RequestBody, @RequestHeader

- CS 네트워크 시간에서 배운 HTTP 패킷의 구조를 생각나게 하는 Annotation이다.

@PostMapping("/order")
public String createPageOrder(
              @RequestBody CreateOrderRequest createOrderRequest,
              @RequestHeader String userAccountId) {
    log.info("Create order : " + createOrderRequest +
             ", userAccountId : " + userAccountId);
    return "orderId : " + createOrderRequest.getOrderId()
            + ", orderAmount : " + createOrderRequest.getOrderAmount();
}

@Data
public static class CreateOrderRequest{
    private String orderId;
    private Integer orderAmount;
}

>> 요청

POST http://localhost:8080/order
Content-Type: application/json
userAccountId: account800

{"orderId" : "123", "orderAmount" : 10000}

>> 응답

http://localhost:8080/order

HTTP/1.1 200 
Content-Type: text/plain;charset=UTF-8
Content-Length: 34
Date: Sat, 10 Sep 2022 18:32:23 GMT
Keep-Alive: timeout=60
Connection: keep-alive

orderId : 123, orderAmount : 10000

|  정리

[ 출처 및 참조 ]

부트 캠프 강의를 들은 후 정리

|  개요

- 스프링은 SOLID 원칙을 담은 아키텍쳐(설계도)에 따라 만든 프레임워크이다.

- 웹 개발 기술의 발전 : HTML -> CGI -> Sevlet/JSP(EJB) -> Spring MVC -> node, ktor 등 경량 웹 프레임워크

- 스프링에 대한 주요 기술은 아래와 같다.

|  스프링의 코어(핵심)

1. DI, IoC, 컨테이너

- 스프링에서는 컨테이너라는 공간 안에 클래스들을 규격화된 Bean형태로 저장한다.

* 수업에서는 컨테이너를 레고판으로, Bean을 레고에 비유했다.

- 이렇게 규격화된 방식을 사용하게 되면 프로젝트의 개발자가 바뀌어도 작업이 원활하게 이루어질 수 있다.

(1) DI(Dependency Injection) - 의존성 주입

(2) IoC(Inversion Of Control) - 제어의 역전

(3) DI 설정 방법의 역사

- DI 설정방법은 XML을 통할 수도 있고, JavaConfig 클래스를 통할 수도 있는데 후자를 많이 사용한다.

- JavaConfig를 사용하는 방법만 보면, 아래와 같이 @Configuration을 통해 이 클래스가 Di config임을 알려주고,

  내부에 사용하려는 각 클래스의 구현체를 @Bean을 통해 전달하는 코드를 담는다.

@Configuration
public class ApplicationConfig{
    @Bean
    public MyService myService(){
    	return new MyService();
    }
}

- 클래스를 Bean으로 등록할 때에는 일일히 @Bean을 치지 않고 각 클래스에 @component를 하면 Bean으로 등록된다.

- 거기에 플러스로 config 파일에 @ComponentScan(//생략)을 추가하면 스프링이 알아서 의존 관계를 찾아준다.

@Configuration
@ComponentScan(basePackages = "com.sample.myApplication")  // 패키지 기준으로 탐색
public class ApplicationConfig{
    
}

// 또는

@Configuration
@ComponentScan(basePackageClasses = MyApplication.class)  // 메인 클래스 기준으로 탐색
public class ApplicationConfig{
    
}

- main함수에서 설정을 호출할때

// DI config 호출
// 1. xml을 사용할 경우
ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("spring-config.xml");
// 2. config클래스를 사용할 경우
ApplicationContext applicationContext =
        new AnnotationConfigApplicationContext(ApplicationConfig.class);

[ Bean 설정 방법 - 더보기 ]

더보기

[ Bean 설정 방법 ]

[1] Bean의 구현체가 여러 개인 경우

(1) @Primary : 구현체에 직접 Primary를 단다.

(2) @Qualifer : 서비스 생성자의 매개변수에 자격 요건을 단다. 

@Component
public class ConveniencePayService { // 편결이

    private final Map<PayMethodType, PaymentInterface> paymentInterfaceMap
            = new HashMap<>();
    private final DiscountInterface discountInterface;

    // 생성자를 통해 결제수단의 종류를 Map으로 저장
    public ConveniencePayService(Set<PaymentInterface> paymentInterfaceSet,
    							 @Qualifier("paymentByMethod")
                                 DiscountInterface discountInterface) {
        paymentInterfaceSet.forEach(
                paymentInterface -> paymentInterfaceMap.put(
                        paymentInterface.getPayMethodType(),
                        paymentInterface
                )
        );
        this.discountInterface = discountInterface;
    }
}

(3) Set 또는 List로 모두 받는다.

(4) 프로퍼티 이름을 Bean과 동일하게 한다.

@Component
public class ConveniencePayService { // 편결이

    private final Map<PayMethodType, PaymentInterface> paymentInterfaceMap
            = new HashMap<>();
    private final DiscountInterface discountInterface;

    // 생성자를 통해 결제수단의 종류를 Map으로 저장
    public ConveniencePayService(Set<PaymentInterface> paymentInterfaceSet,
    							 DiscountInterface discountByPayMethod) {
        paymentInterfaceSet.forEach(
                paymentInterface -> paymentInterfaceMap.put(
                        paymentInterface.getPayMethodType(),
                        paymentInterface
                )
        );
        this.discountInterface = discountByPayMethod;
    }
}

 

[2] Scope설정하기

- 싱글톤 : default설정(아무것도 설정X시)

- Prototype : 데이터를 클렌징할 때 사용하며, 매번 새로 Bean을 생성한다.

ㄴ Request/Session/Web Socket

 

[3] Profile

- 인텔리j의 경우, 실행버튼 좌측에 셀렉박스 선택 - [Edit Configuration...] 에서 개발 환경변수를 입력할 수 있고

- 쉘에 직접 칠 경우, - Dspring.profiles.active = sandbox, beta, production 로 개발 환경변수를 입력할 수 있다.

- 특정 환경에서만 사용할 클래스에 @Profile("test")와 같이 작성하면 된다.

@Component
@Profile("test")
public class DiscountByConvenience implements DiscountInterface{
}

2.  스프링의 부가기능 - Resource, AOP, Validation&Data Binding, SpEL

(1) Resource(외부 자원)

- 추가 파일 로딩

@Service
public calss ResourceService{
    @AutoWired
    ApplicationContext ctx;
    
    public void setResource(){
    	Resource myTemplate = ctx.getResource("classPath:some/resource/path/myTemplate.txt");
    }
}

- ApplicationContext(스프링의 핵심설정)을 이루는 설정값을 가져오기

// 스프링의 핵심설정을 이루는 설정값을 가져오기
ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/appContext.xml");
ApplicationContext ctx = new FileSystemXmlApplicationContext("conf/appContext.xml");
ApplicationContext ctx = new FileSystemXmlApplicationContext("classpath:conf/appContext.xml");

Bear bear = (Bear) ctx.getBean("bear");

(2) AOP(Aspect Orient Programing, 관점지향 프로그래밍)

* 로깅/트랜잭션이란?

- 간단히 말해 로깅은 로그(log) 곧, 기록을 남기는 것을 말하고, 

- 트랜잭션이란 DB관련 작업 단위를 말하는 것으로 DB와의 작업을 한다는 의미이다.

- AOP 예시 코드

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect    // Aspect 생성
@Component // Aspect Class를 스프링 Bean으로 등록
public class CertainAspect{
    @PointCut("execution(public * *(..))") // public 대상 PointCut선언
    private void certainAdviceA(){
    	// 조건식 생성
    }
    
    @PointCut("within(com.xyz.myapp.trading..*)") // 특정 패키지 대상 PointCut선언
    private void certainAdviceB(){
    	// 조건식 생성
    }
    
    @PointCut("certainAdviceA() && certainAdviceB()") // PointCut결합
    private void mergeAdvice(){
    	// 조건식 생성
    }
}

- 미리 정의된 포인트컷의 before/after/around에 advice실행

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect    // Aspect 생성
public class CertainAspect{
    @Before("com.xyz.myapp.certainPointCutMethod()")
    private void certainAdvice(){
    	
    }
    
    @AfterReturning("com.xyz.myapp.certainPointCutMethod()")
    private void certainAdvice(){
    	
    }
    
    @Around("com.xyz.myapp.certainPointCutMethod()")
    private void certainAdvice(){
    	
    }
}

(3) Validation & Data Binding

- Validation

- Data Binding

(4) 스프링 표현 언어 (SpEL)

|  MVC

- MVC란? Model + View + Controller 의 약자

- 최근에는 일반적으로 Request와 Response 모두 JSON 타입을 사용한다.

- Spring MVC의 흐름

|  스프링 프로젝트 생성하기

1. 프로젝트 생성하기

[1] https://start.spring.io/ 에서 프로젝트를 하나 만들어 생성 

- 압축파일 해제한 뒤 IDE에 가져와 Build를 보면 아래와 같은데, 알아서 기본 세팅을 해준 걸 볼 수 있다.

/* 플러그인의 의존성(library) 관리 */
plugins {
	id 'org.springframework.boot' version '2.7.3'
	id 'io.spring.dependency-management' version '1.0.13.RELEASE'
	id 'java'
}

group = 'com.zerobase'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

/* 각종 의존성들(libraries)을 어떤 원격 저장소에서 받을 것인지 지정 */
repositories {
	mavenCentral() // jcenter로 업로드 설정을 간소화할 수 있다.
}

/* 프로젝트 개발에 필요한 의존성들을 선언하는 곳 */
dependencies {
	implementation 'org.springframework.boot:spring-boot-starter'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

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

[2] 인텔리j를 통해 바로 프로젝트 생성

[ 정리 ]

[ 참고 및 출처 ]

부트캠프 수업 내용 정리

mvc란? https://hanamon.kr/mvc%EB%9E%80-mvc-design-pattern/

트랜잭션이란 https://mommoo.tistory.com/62

spring MVC https://codingnotes.tistory.com/28

프레임워크와 라이브러리, OOP와 AOP https://geminihoroscope.tistory.com/104

|  자바 웹 프로그래밍

- 동적인 웹사이트를 만들기 위해서 과거부터 지금까지 아래와 같은 역사를 거쳐왔다.

- CGI는 프로세스단위로 동적 페이지를 생성하기 때문에 자원의 효율성이 떨어졌기에 

- Servlet을 통해 쓰레드단위로 동적 페이지를 생성하여 극복하고자 하였다.

- EJB는 여기에 데이터의 저장 및 수정 시의 안정성을 높이고 트랜잭션 처리 기능을 추가 한 것으로

             안정적인 코딩을 가능해졌지만, 코드가 너무 복잡해서 테스트 코드를 생성하는 것도 어려웠다고 한다.

- 이때, Rod Johnson이라는 사람이 자반만의 쉬운 자바 웹 프로그래밍 방법을 담은 도서를 지필하면서,

  개발자 사이에 해당 코딩이 붐을 이루었는데, 이 코드 방식을 아예 프레임워크로 만든 것이 오늘날의 스프링이라고 한다.

|  스프링과 SOLID 원칙

- 객체지향에 대해서 다루면서 SOLID에 대해서 배웠었다. 바로가기

- 스프링은 자체적으로 이 SOLID 원칙을 지키는 프로그래밍을 지원한다.

1.  스프링의 웹 MVC 3-tier 아키텍처 : SRP 지원(분류)

- SRP는 "하나의 클래스는 단일 책임을 지어야한다"는 원칙이다.(Single Responsibility Principle)

  * SRP는 클래스의 응집도와 관련이 있으며,

    전체 기능들이 확장되고 세분화될 수록 클래스 분류가 애매모호해지는 이슈가 생기는 걸 방지한다.

- 스프링은 아래와 같이 3개의 단계를 가진 아키텍처에 의해 만들어진 프레임워크이다.

- OSI 7-layer와도 유사한 형태로,

  단계별로 역할을 나누어주어 클래스 역할이 더 명확해지고 코드파악이 더 쉬워지게 한다.

2. 스프링의 DI 컨테이너와 DI config - OCP, LSP, DIP 지원(교체)

- SOLID 중 DIP는 의존성 역전 원칙으로써, 하위 모듈간의 의존관계를 중간 인터페이스를 통해 해소할 것을 제안한다.

- 스프링에는 DI 컨테이너(의존성 주입 컨테이너, Dependency Injection Cotainer)가 있다.

- 더불어 DI 컨테이너 내에는 DI config가 존재하는데, DI config는 의존 클래스를 변경하는 설정(config)을 한다.

- 따라서 스프링을 사용하면 보다 쉽게 DIP를 지킨 코딩이 가능해진다.

|  스프링에 관한 참조 사이트

- 수업 시간에 평소 알고 있었던 구글 검색이나, 스택오버플로우 페이지 외에도 두 가지의 참조 사이트를 소개받았다.

- 처음 접하게 된 사이트들이어서 신기한 마음에 몇 가지 페이지들을 공유해보고 싶다.

- Baeldung의 Start Here페이지이다. 튜토리얼을 제공하고 있는데 일반 코스에서 시큐어 코딩, REST API까지 다룬다.

  돈 주고 배워야 하는 내용들이 다 들어가 있다. 아름다운 사이트..

- Medium이라는 사이트는 일반 블로그 사이트같다. IT뿐 아니라 여러 분야를 다 섭렵하고 있는데,

  [technoligies]인가 태그를 선택해 들어가보니, 아래처럼 IT 기술 관련된 포스팅이 많이 있었다.

  신기한 건 TTS까지 제공해주고 있다는 거다. 진정한 의미의 웹 접근성 달성을 이룬 사이트다.

[ 참고 및 출처 ]

부트캠프 강의를 들은 후 배운 내용을 복습한 내용입니다.