Spring에서 REST API를 구현할 때, Spring JPA와 Jackson을 많이 사용한다. 이 환경에서 양방향 연관관계를 매핑할 때 무슨 문제가 있을까?

순환 참조??

두 객체가 서로를 참조하면서 참조의 참조를 하는상황

@Entity
public class User {
    @OneToMany(mappedBy = "user")
    private List<Post> posts;
}

@Entity
public class Post {
    @ManyToOne
    private User user;
}

이 구조에서 User는 Post 리스트를 가지고 있고, Post는 다시 User를 참조 참조가 끝없이 반복되며, 결국 StackOverflowError 또는 API 무한 응답 대기 문제가 발생

중요한 이유

• 프론트엔드로 JSON 데이터를 보낼 때 응답이 끝나지 않음
• 로깅이나 디버깅 시 콘솔 출력조차 안 됨
• Jackson이 객체 그래프를 순회하면서 순환 루프에 빠지기 때문
  

해결 방법

1. @JsonIgnore

해당 필드를 직렬화 대상에서 완전히 제외하는 방법

@Entity
public class Post {
    @Id @GeneratedValue
    private Long id;
    private String title;

    @ManyToOne
    @JoinColumn(name = "user_id")
    @JsonIgnore
    private User user;
}

장점

• 구현이 간단하고, 순환 참조 문제가 즉각 해결됨

단점

• 무조건 직렬화에서 제외되므로, 클라이언트가 Post 객체 안의 user 정보가 필요할 경우 별도 처리 필요
• 양방향 정보 제공이 불가능해, 필요하다면 DTO 변환 로직이 복잡해질 수 있음

2. @JsonManagedReference / @JsonBackReference

Jackson이 부모‒자식 관계를 인식하도록 표시

@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy = "user")
    @JsonManagedReference
    private List<Post> posts;
}

@Entity
public class Post {
    @Id @GeneratedValue
    private Long id;
    private String title;

    @ManyToOne
    @JoinColumn(name = "user_id")
    @JsonBackReference
    private User user;
}

• @JsonManagedReference가 붙은 쪽(User.posts)은 직렬화(serialize) 시 포함
• @JsonBackReference가 붙은 쪽(Post.user)은 역직렬화(deserialize) 시 포함, 직렬화 시엔 무시

  장점

• 부모 → 자식 방향은 JSON에 노출, 자식 → 부모 방향 순환은 차단
• 양방향 데이터가 일부 필요한 경우 활용 가능

주의사항

• 관계가 둘 이상이면 각각에 대해 value 속성으로 식별자 지정 필요
• JPA 매핑과 Jackson 매핑이 분리되어 관리 포인트가 늘어남

3. @JsonIdentityInfo

같은 객체가 반복될 경우 중복 출력하지 않고 참조만 남기는 방식

@Entity
@JsonIdentityInfo(
    generator = ObjectIdGenerators.PropertyGenerator.class,
    property = "id"
)
public class User {
    @Id
    private Long id;
    private String name;

    @OneToMany(mappedBy = "user")
    private List<Post> posts;
}

@Entity
@JsonIdentityInfo(
    generator = ObjectIdGenerators.PropertyGenerator.class,
    property = "id"
)
public class Post {
    @Id
    private Long id;
    private String title;

    @ManyToOne
    private User user;
}

장점

• 순환 참조를 안전하게 처리할 수 있음
• 복잡한 객체 그래프에서도 유지보수 부담 없이 순환 해결 가능

단점

• 프론트엔드에서 ID로 다시 객체를 매핑해야 하므로 가독성이 떨어질 수 있음
• 객체 전체가 아닌 참조 ID만 노출되기 때문에 추가 요청 없이 데이터를 바로 사용할 수 없음

언제 사용하는가?

• 관계가 깊고 엮인 구조가 많아 @JsonIgnore 또는 @JsonManagedReference로는 감당이 어려울 때
• 복잡한 객체 그래프를 객체 ID 중심으로 표현하는 게 적절한 시스템 (예: 그래프 DB, 트리 구조 등)
• 빠르게 순환 참조를 막고 싶은 경우

4. DTO

DTO(Data Transfer Object)는 엔티티(Entity)의 데이터를 클라이언트에 전달하거나 요청받기 위한 전용 객체

public class TagPlainDto {
    private Long id;
    private String name;

    public static TagPlainDto fromEntity(TagPlain tag) {
        return new TagPlainDto(tag.getId(), tag.getName());
    }

    // Constructor, Getter
}

장점

• 순환 참조 문제 해결
• 보안성 향상
• 도메인 모델과 분리된 API 구조

단점

• 코드가 늘어남
• 변환 로직 필요
• 성능 고려 필요
  

결론

스프링을 통해 REST API를 구축하다보면 객체(DTO)를 반환하는 일은 매우 자주있다.

// UserResponse.java
public class UserResponse {
    private String name;
    private int age;

    public UserResponse() {
        name = "Chan";
        age = 27;
    }
}


// MainController.java
@RestController
public class MainController {

    @GetMapping("/api/v1/users")
    public UserResponse getUsers() {
        UserResponse response = new UserResponse();
        return response;
    }
}

다음의 코드를 보고 잘못된 부분을 찾아 보자. 분명 틀린 부분이 없어보이지만, 심지어 실행에도 문제가 없지만 실행을 하면, 다음과 같은 문제가 발생한다.

🔴 HTTP Status 406 - Not Acceptable ??

이 상태 코드는 클라이언트가 요청할 때 지정한 Accept 헤더에 서버가 응답 가능한 타입이 없다는 뜻입니다. 즉, 서버가 JSON을 제공하지 못했다는 것! 무엇이 문제일까? 좀 더 알아보자.

단계별로 알아보기

@RestController ??

@Controller + @ResponseBody

해당 클래스의 모든 메서드는 반환값을 View가 아닌 HTTP 응답 본문(body)에 직접 쓴다. 즉, 객체를 반환에 직접 사용!

객체반환? - 어떻게??

기본적으로 Spring은 반환 시 HttpMessageConverter를 사용. 객체를 반환하면 Spring은 자동으로 객체를 JSON으로 변환한다. 이때, MappingJackson2HttpMessageConverter를 사용! 객체를 JSON으로 변환을 한다!

JSON 변환은 누가??

MappingJackson2HttpMessageConverter은 Jackson 라이브러리를 사용한다. Jackson은 객체를 JSON으로 직렬화함!

왜 문제가 발생하는가?

Jackson의 직렬화에 대한 문제

Jackson은 직렬화 시, 다음 중 하나를 필요로 함

• public 필드
• getter 메서드

결국 private 필드인데 getter가 없으면 JSON 직렬화 실패

올바른 코드

// UserResponse.java
public class UserResponse {
    private String name;
    private int age;

    public UserResponse() {
        name = "Chan";
        age = 27;
    }

    public String getName() {
        return "HaeChan";
    }
}

다음과 같이 getter가 있어야 작동한다. 다음을 통해 Spring에서 RestController에서 객체 반환 시, Getter의 내용을 사용한다는 것을 알 수 있다.

심화학습

Jackson을 이용하기 때문에

@JsonIgnore
@JsonProperty
@JsonManagedReference
@JsonBackReference

다음과 같은 어노테이션을 사용할 수 있음

• @JsonIgnore: 해당 필드를 JSON 직렬화/역직렬화에서 제외

• @JsonProperty: JSON의 필드 이름을 Java 필드와 다르게 지정

• @JsonManagedReference & @JsonBackReference: 두 어노테이션은 양방향 관계에서 순환 참조로 인해 StackOverflow가 발생하는 것을 방지 @JsonManagedReference → 직렬화에 포함됨 (보통 부모 → 자식 방향) @JsonBackReference → 직렬화에서 제외됨 (보통 자식 → 부모 방향)

• @JsonIdentityInfo: Jackson이 객체의 ID 기반으로 참조를 추적하게 하여, 순환 참조 구조에서도 무한 루프 없이 직렬화가 가능

ObjectMapper를 사용하기

ObjectMapper는 Jackson 라이브러리의 핵심 클래스

직접 사용하기

ObjectMapper objectMapper = new ObjectMapper();

// 직렬화: Java 객체 → JSON
User user = new User("haechan", 25);
String json = objectMapper.writeValueAsString(user);

// 역직렬화: JSON → Java 객체
String jsonString = "{\"name\":\"haechan\",\"age\":25}";
User user2 = objectMapper.readValue(jsonString, User.class);

커스텀 마이징

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();

        // 예: snake_case → camelCase 자동 매핑
        mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);

        // null 값 무시
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        return mapper;
    }
}

다음과 같이 커스텀해서 사용할 수 있다.

정리

• Spring은 객체 반환 시, Jackson을 사용한다.
• 따라서, public 혹은 getter가 반드시 필요하다.
  

실습 후 배운 것을 적용해보는 시간 AIVLE SCHOOL에서는 7번의 미니 프로젝트를 진행

주어지는 것

• 미션, 데이터, 도메인 정보, 가이드

해야하는 것

• 데이터 분석, 배운 것을 적용하여 문제를 해결하기
  

진행 방식

1. 해결해야 할 미션, 데이터, 도메인 정보, 가이드가 제공
2. 개별실습을 통해 주어진 시간 내미션을스스로해결
3. 조별실습을 통해 부족한부분을서로배우고공동과제를수행
4. 전체발표 시간에는 조별 솔루션을 공유하고인사이트를습득
5. 프로젝트에 따라 개인/조별 과제 제출 및 Self-Test로 마무리

• 다음과 같은 목표가 주어진다!!
  

미니 프로젝트 정리

주제

• 1차: 데이터 분석 및 의미찾기
• 2차: 머신러닝
• 3차: 딥러닝
• 4차: 시각지능 딥러닝
• 5차: 언어지능 딥러닝
• 6차: 에이스(AICE) 자격증 준비 + 데이터 분석 정리
• 7차: AI 웹 서비스

강의장

• 수도권은 2개의 강의장이 있음!

1. 전농 교육장
2. 분당 교육장

미니프로젝트 팁

• 못해도 최선을 다하기!
• 팀원이랑 의사소통 최대한 많이 하기
• 강의장을 무조건 활용하기
• 오프라인 소통이 제일 중요함
  

미니 프로젝트 맛보기

주제

• 어느 구에 버스정류장을 추가하는 것이 좋은가?

제공 데이터

• 버스 이용객, 교통 수요, 현 상황 등등

목표

• 데이터 분석을 통해 적합한 지역을 찾자!

가이드

• 버스 이용객, 교통 수요 데이터 분석
• 머신러닝을 이용한 교통 수요 예상
• 여러 도구를 사용하여 인사이트 도출

• Linear Regression
• K-Nearest Neighbor
• Decision Tree
• Logistic Regression
• Random Forest
• XGBoost
• Light GBM
  

Linear Regression

• 이름과 같이 회귀만 가능!
• 선형 직선을 이용하여 값을 예측하는 방식

  단순 회귀

• 독립변수 개수로 회귀분석을 단순 회귀와 다중 회귀로 분류
• 독립변수 하나가 종속변수에 영향을 미치는 선형 회귀
• 𝑥 값 하나만으로 𝑦값을 설명할 수 있는 경우
• 독립변수의 최선의 가중치와(w1)와 편향(w0)을 찾음

다중 회귀

• 여러 독립변수가 종속변수에 영향을 미치는 선형 회귀
• 𝑦 값을 설명하기 위해서는 여러 개의 𝑥 값이 필요한 경우
• 각 독립변수의 최선의 가중치와(w1, w2, w3, w4…)와 편향(w0)을 찾음

code

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

K-Nearest Neighbor

• k-Nearest Neighbor: k 최근접 이웃(가장 가까운 이웃 k개)
• 학습용 데이터에서 k개의 최근접 이웃의 값을 찾아 그 값들로 새로운 값을 예측하는 알고리즘
• 회귀와 분류에 사용되는 매우 간단한 지도학습 알고리즘
• 다른 알고리즘에 비해 이해하기 쉽지만, 연산 속도가 느림

  k값의 중요성

• k(탐색하는 이웃 개수)에 따라 데이터를 다르게 예측할 수도 있음
• k 값에 따라 예측 값이 달라지므로 적절한 k 값을 찾는 것이 중요(기본값=5)
• 검증 데이터로 가장 정확도가 높은 k를 찾아 KNN 알고리즘의 k로 사용

Scaling

• 거리를 사용하기 때문에 정규화가 성능에 영향을 미침

  # 함수 불러오기
  from sklearn.preprocessing import MinMaxScaler
  # 정규화
  scaler = MinMaxScaler()
  # scaler.fit(x_train)
  x_train = scaler.fit_transform(x_train)
  x_test = scaler.transform(x_test)

code

# 회귀모델
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_absolute_error, r2_score
# 분류모델
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import confusion_matrix, classification_report
# 선언하기
model = KNeighborsRegressor(n_neighbors=5)

Decision Tree

• 특정 변수에 대한 의사결정 규칙을 나무 가지가 뻗는 형태로 분류해 나감
• 분류와 회귀 모두에 사용되는 지도학습 알고리즘
• 분석 과정이 직관적이며, 이해와 설명하기가 쉬움
• 스케일링 등의 전처리 영향도가 크지 않음
• 과적합으로 모델 성능이 떨어지기 쉬움
• 트리 깊이를 제한하는(=가지치기) 튜닝이 필요

가지치기

• 가지치기를 하지 않으면 모델이 학습 데이터에는 매우 잘 맞지만, 평가 데이터에는 잘 맞지 않음
• 여러 하이퍼파라미터 값을 조정해 가지치기 할 수 있음
  • max_depth, min_samples_leaf, min_samples_split 등
• 학습 데이터에 대한 성능은 낮아지나, 평가 데이터에 대한 성능을 높일 수 있음
• 가장 적절한 하이퍼파라미터 값을 찾도록 노력해야 함

code

# 회귀모델
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_absolute_error, r2_score
# 분류모델
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, classification_report

# 선언하기
model = DecisionTreeRegressor(max_depth=5)

Logistic Regression

• Sigmoid를 활용하여 분류만 가능한 모델!

로지스틱 함수

• 시그모이드(sigmoid) 함수라고도 부름
• 확률 값 𝑝 는 선형 판별식 값이 커지면 1, 작아지면 0에 가까운 값이 됨
• (-∞, ∞) 범위를 갖는 선형 판별식 결과로 (0, 1) 범위의 확률 값을 얻게 됨
• 기본적으로 확률 값 0.5를 임계값(Threshold)로 하여 이보다 크면 1, 아니면 0으로 분류함
• 𝑥 데이터가 주어졌을 때 확률을 예측하는 로지스틱 회귀분석은 학습 데이터를 잘 설명하는 선형 판별식의 기울기(𝑎)와 절편(𝑏)을 찾는 문제

code

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, classification_report
# 선언하기
model = LogisticRegression()

앙상블(Ensemble)

• 통합은 힘이다(Unity is strength)
• 약한 모델이 올바르게 결합하면 더 정확하고 견고한 모델을 얻을 수 있다!
• 여러 개의 모델을 결합하여 훨씬 강력한 모델을 생성하는 기법

배깅(Bagging)

• Bootstrap Aggregating의 약자
• 데이터로부터 부트스트랩 한 데이터로 모델들을 학습시킨 후, 모델들의 예측 결과를 집계해 최종 결과를 얻는 방법
• 같은 유형의 알고리즘 기반 모델들을 사용
• 데이터 분할 시 중복을 허용(복원 랜덤 샘플링 방식이라고 함)
• 범주형 데이터(Categorical Data)는 투표 방식(Voting)으로 결과를 집계
• 연속형 데이터(Continuous Data)는 평균으로 결과를 집계
• 대표적인 배깅 알고리즘: Random Forest

부스팅(Boosting)

• 같은 유형의 알고리즘 기반 모델 여러 개에 대해 순차적으로 학습을 수행
• 이전 모델이 제대로 예측하지 못한 데이터에 대해서 가중치를 부여하여 다음 모델이 학습과 예측을 진행하는 방법
• 계속하여 모델에게 가중치를 부스팅하며 학습을 진행해 부스팅 방식이라 함
• 예측 성능이 뛰어나 앙상블 학습을 주도함
• 배깅에 비해 성능이 좋지만, 속도가 느리고 과적합 발생 가능성이 있음
• 대표적인 부스팅 알고리즘: XGBoost, LightGBM

code

# 회귀모델
from sklearn.ensemble import RandomForestRegressor
from xgboost import XGBRegressor
from sklearn.metrics import mean_absolute_error, r2_score

# 분류모델
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import confusion_matrix, classification_report


# 선언하기
model = RandomForestRegressor(max_depth=5, n_estimators=100, random_state=1)
model = XGBRegressor(max_depth=5, n_estimators=100, random_state=1)

• 데이터를 기반으로 학습하여 특정 작업을 수행하는 것
• 인간의 경험 = 머신의 데이터
• 데이터를 통해 학습을 하는 것
  # 머신러닝 종류 분류 ## 학습 방법에 따른 분류 >#### 지도학습
• 학습 대상이 되는 데이터에 정답을 주어 규칙성, 즉 데이터의 패턴을 배우게 하는 학습 방법

  비지도 학습

• 정답이 없는 데이터 만으로 배우게 하는 학습 방법

  강화 학습

• 선택한 결과에 대해 보상을 받아 행동을 개선하면서 배우게 하는 학습 방법

과제에 따른 분류

분류문제

• 이미 적절히 분류된 데이터를 학습하여 분류 규칙을 찾고, 그 규칙을 기반으로 새롭게 주어진 데이터를 적절히 분류하는 것을 목적으로 함(지도 학습)

  회귀문제

• 이미 결과값이 있는 데이터를 학습하여 입력 값과 결과 값의 연관성을 찾고, 그 연관성을 기반으로 새롭게 주어진 데이터에 대한 값을 예측하는 것을 목적으로 함(지도 학습)

  클러스터링

• 주어진 데이터를 학습하여 적절한 분류 규칙을 찾아 데이터를 분류함을 목적으로 함, 정답이 없어 성능 평가가 어려움(비지도 학습)

분류 vs 회귀

• 분류와 회귀에 따라 사용할 알고리즘과 평가 함수가 달라짐
• 예측 값에 연속성이 있으면 회귀
  

용어 정리

모델(Model)

• 데이터로부터 패턴을 찾아
• 수학식으로 정리해 놓은 것
• 모델링(Modeling): 오차가 적은 모델을 만드는 과정

  모델의 목적

• 샘플을 가지고 전체를 추정
  • 샘플: 표본, 부분집합, 일부, 과거의 데이터
  • 전체: 모집단, 전체집합, 현재와 미래의 데이터
  • 추정: 예측, 추론

    행(Column)

• 특성, 속성, 변수, 필드

  열(Row)

• 개체, 관측치, 기록, 사례, 경우

  독립변수, 종속변수

• 독립변수를 𝑥 로, 종속변수를 𝑦로 표시함
• 독립변수(원인)
• 종속변수(결과)

  오차

• 통계학에서 사용되는 가장 단순한 모델 중 하나가 평균
• 관측값(=실젯값)과 모델 예측값의 차이: 이탈도(Deviance) → 오차

  데이터 분리

• 데이터 셋을 학습용, 검증용, 평가용 데이터로 분리 함
• 평가용 데이터는 별도로 제공되는 데이터일 경우가 많음
• 검증용 데이터로 평가 전에 모델 성능을 검증해 볼 수 있음(튜닝 시 사용)

  과대적합(Overfitting)

• 학습 데이터에 대해서는 성능이 매우 좋은데, 평가 데이터에 대해서는 성능이 매우 좋지 않은 경우
• 학습 데이터에 대해서만 잘 맞는 모델 → 실전에서 예측 성능이 좋지 않음

  과소적합(Underfitting)

• 학습 데이터보다 평가 데이터에 대한 성능이 매우 좋거나, 모든 데이터에 대한 성능이 매우 안 좋은 경우
• 모델이 너무 단순하여 학습 데이터에 대해 적절히 훈련되지 않은 경우
  

모델링 코드

구조

1. 불러오기
2. 선언하기
3. 학습하기
4. 예측하기
5. 평가하기

   #1
   from sklearn.linear_model import LinearRegression
   from sklearn.metrics import mean_absolute_error
   

#2 model = LinearRegression()

#3 model.fit(x_train, y_train)

#4 y_pred = model.predict(x_test)

#5 mean_absolute_error(y_test, y_pred)

<br>

# 성능평가
## 회귀 모델 성능 평가
![](https://velog.velcdn.com/images/chane_ha_da/post/68370984-411f-4eb9-a964-27555772fb15/image.png)
### 결정 계수 R^2(R-Squared)
- Coefficient of Determination
- MSE로 여전히 설명이 부족한 부분이 있음(성능이 확실히 와 닿지 않음)
- 모델 성능을 잘 해석하기 위해서 만든 MSE의 표준화된 버전이 결정 계수임
- 전체 오차 중에서 회귀식이 잡아낸 오차 비율(일반적으로 0 ~ 1 사이)
- 오차의 비 또는 설명력이라고도 부름
- 𝑅^2 = 1이면 𝑀𝑆𝐸 = 0이고 모델이 데이터를 완벽하게 학습한 것
![](https://velog.velcdn.com/images/chane_ha_da/post/ab773623-35df-455e-a9c1-8467b9d64f2e/image.png)

### code
```python
# 함수 불러오기
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_absolute_percentage_error
from sklearn.metrics import r2_score

# 평가하기
# mean_absolute_error(실젯값, 예측값)
print(mean_absolute_error(y_test, y_pred))

분류 모델 성능 평가

Accuracy(정확도)

• 정분류율 이라고 부르기도 함
• 전체 중에서 Positive와 Negative 로 정확히 예측한(TN + TP) 비율
• Negative를 Negative로 예측한 경우도 옳은 예측임을 고려하는 평가지표
• 가장 직관적으로 모델 성능을 확인할 수 있는 평가지표

Precision(정밀도) / 예측 관점

• Positive로 예측한 것(FP + TP) 중에서 실제 Positive(TP)인 비율
• 비가 내릴 것으로 예측한 날 중에서 실제 비가 내린 날의 비율

Recall(재현율) / 실제 관점

• 실제 Positive(FN + TP) 중에서 Positive로 예측한(TP) 비율
• 민감도(Sensitivity)라고 부르는 경우가 많음
• 실제 비가 내린 날 중에서 비가 내릴 것으로 예측한 날의 비율

Specificity(특이도)

• 실제 Negative(TN + FP) 중에서 Negative로 예측한(TN) 비율
• 실제 비가 내리지 않은 날 중에서 비가 내리지 않을 것으로 예측한 날의 비율

F1-Score

• 정밀도와 재현율의 조화 평균
• 분자가 같지만 분모가 다를 경우, 즉 관점이 다른 경우 조화 평균이 큰 의미를 가짐
• 정밀도와 재현율이 적절하게 요구 될 때 사용

code

# 함수 불러오기
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

# 평가하기
# accuracy_score(실젯값, 예측값)
print(accuracy_score(y_test, y_pred))
print(precision_score(y_test, y_pred, average=None))

@Valid 어노테이션을 사용하면 사용자의 요청을 검증할 수 있다. 간단하게 검증에 대해서 알아보고 좀 더 복잡한 검증을 처리해보자!

Valid?

dependencies

implementation 'org.springframework.boot:spring-boot-starter-validation'

Annotations

@Size

@NotNull

@NotEmpty

@NotBlank

@Past

@Future

@FutureOrPresent

@Max

@Min

@Pattern

@Valid

@Email

code

public class PortfolioInputItemDTO {
    @NotNull(message = "Stock name must not be null")
    private String stockName;

    @Min(value = 0, message = "Weight must be at least 0")
    @Max(value = 1, message = "Weight must be at most 1")
    @NotNull(message = "weight must not be null")
    private float weight;
}

• 다음과 같이 사용하고, 여러 개를 한번에 사용할 수 있음
• message의 경우 예외처리시 전달할 내용을 지정!

예외 발생 처리 과정

다음의 과정에서 Handler Mapping 단계에서 @Valid 또는 @Validated가 붙은 파라미터가 있는 경우 유효성 검사

• 검증 실패 시 MethodArgumentNotValidException가 발생함
• @ControllerAdvice 어노테이션을 사용하여 정의된 전역 예외 처리기가 있는 경우, 그 메서드가 호출
  

사용자 정의 검증하기!

What?

public class PortfolioInputItemDTO {
    private List<Stock> stocks;
    //Stock(String name, float weight)
}

• 다음 DTO에서 List의 Stock의 weight의 합이 1인지 검증을 하고 싶다.
• 기존의 Annotations만을 이용해서는 불가능하다!

Process

1. Annotation을 정의한다.
2. 검증식을 만든다.
3. 사용하기

In use

public class PortfolionputDTO {
    private LocalDate startDate;
    private LocalDate endDate;
    private List<PortfolioInputItemDTO> portfolioInputItemDTOList;
}

1. startDate < endDate인지 검증
2. List의 weight의 합이 1이 되도록 검증

1. Annotation 정의하기

import jakarta.validation.Constraint;
import jakarta.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Constraint(validatedBy = PortfolioInputValidator.class)
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ValidPortfolioInput {
    String message() default "Valid Error";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

• @Constraint(validatedBy = PortfolioInputValidator.class): 유효성 검사를 수행할 클래스를 지정
• @Target({ElementType.TYPE}): 적용 범위를 클래스로 설정
• @Retention(RetentionPolicy.RUNTIME): 런타임 동안 유지
• message: 검사 실패시 전달할 기본 메시지

검증 클래스 만들기

import com.chan.stock_portfolio_backtest_api.dto.PortfolioInputItemDTO;
import com.chan.stock_portfolio_backtest_api.dto.PortfolionputDTO;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import java.time.LocalDate;
import java.util.List;

public class PortfolioInputValidator implements ConstraintValidator<ValidPortfolioInput, PortfolionputDTO> {
    @Override
    public boolean isValid(PortfolionputDTO portfolionputDTO, ConstraintValidatorContext constraintValidatorContext) {
        constraintValidatorContext.disableDefaultConstraintViolation();

        if (portfolionputDTO == null) {
            return true;
        }

        //startDate < endDate valid
        LocalDate startDate = portfolionputDTO.getStartDate();
        LocalDate endDate = portfolionputDTO.getEndDate();
        if (startDate != null && endDate != null) {
            if (!startDate.isBefore(endDate)) {
                constraintValidatorContext
                        .buildConstraintViolationWithTemplate("endDate must be after the startDate")
                        .addPropertyNode("endDate")
                        .addConstraintViolation();
                return false;
            }
        }

        //weight sum == 1 valid
        List<PortfolioInputItemDTO> portfolioInputItemDTOList = portfolionputDTO.getPortfolioInputItemDTOList();
        float weightSum = 0;
        for (PortfolioInputItemDTO i : portfolioInputItemDTOList) {
            weightSum += i.getWeight();
        }

        if (weightSum != 1) {
            constraintValidatorContext
                    .buildConstraintViolationWithTemplate("weight sum is might be 1")
                    .addPropertyNode("portfolioInputItemDTOList")
                    .addConstraintViolation();
            return false;
        }

        return true;
    }
}

• ConstraintValidator<어노테이션, 적용할 클래스>을 상속받아서 구현해야함
• public boolean isValid(): 다음을 오버라이딩 하여 구현해야함
• constraintValidatorContext.disableDefaultConstraintViolation(): 기본 메세지를 제거하는 부분

    if (!startDate.isBefore(endDate)) {
        constraintValidatorContext
                .buildConstraintViolationWithTemplate("endDate must be after the startDate")
                .addPropertyNode("endDate")
                .addConstraintViolation();
        return false;
    }

• 다음과 같이 false를 반환하면 유효성 검사를 실패로 설정
• constraintValidatorContext을 사용해 메세지와 Property를 추가할 수 있음

사용하기

@ValidPortfolioInput
public class PortfolionputDTO {
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @NotNull(message = "Start date must not be null")
    private LocalDate startDate;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @NotNull(message = "End date must not be null")
    private LocalDate endDate;

    @Valid
    private List<PortfolioInputItemDTO> portfolioInputItemDTOList;
}

• 다음과 같이 만든 어노테이션을 클래스에 추가하여 사용할 수 있다.

• 웹서비스의 여러 페이지를 이동하며 데이터를 수집하는 작업

웹크롤링 방법

웹페이지의 종류

• 정적인 페이지 : 웹 브라우져에 화면이 한번 뜨면 이벤트에 의한 화면의 변경이 없는 페이지
• 동적인 페이지 : 웹 브라우져에 화면이 뜨고 이벤트가 발생하면 서버에서 데이터를 가져와 화면을 변경하는 페이지

requests 이용

1. json 문자열로 받아서 파싱하는 방법 : 주로 동적 페이지 크롤링할때 사용
2. html 문자열로 받아서 파싱하는 방법 : 주로 정적 페이지 크롤링할때 사용

selenium 이용

• 브라우져를 직접 열어서 데이터를 받는 방법

속도 비교 requests json > requests html > selenium

requests 방식 크롤링

import

import requests
import pandas as pd # 데이터 처리를 위한

URL 구성하기

• 개발자 모드 -> 네트워크 상 URL을 가져옴

  page, page_size = 1, 60
  url = f'https://m.stock.naver.com/api/index/KOSPI/price?\pageSize={page_size}&page={page}'
  

## 요청하고 응답받기
```python
response = requests.get(url)
response

다음과 같이 200을 출력한다면 정상적으로 응답을 받아온 것이다.

df 구성하기

columns = ["localTradedAt", "closePrice"]
data = response.json()
kospi_df = pd.DataFrame(data)[columns]
kospi_df

requests(REST API-공공데이터 포탈)

import

import requests, json
import pandas as pd # 데이터 처리를 위한

URL 구성하기

API 키 및 파라미터 설정

REST_API_KEY = "your-key"
resultType = 'json'
basDt = '20241105'

URL

url = f'http://apis.data.go.kr/1160100/service/GetStockSecuritiesInfoService/getStockPriceInfo?serviceKey={REST_API_KEY}&resultType={resultType}&basDt={basDt}'

요청하고 응답받기

response = requests.get(url)
response

응답 분석하고 데이터로 json 형식 변경하기

• 다음과 같은 구조를 가진다.
• item들을 불러오기 위해서 response>body>items>item을 찾아야 한다.

data = repsonse.json()['response']['body']['items']['item']

df 구성하기

df = pd.DataFrame(data)
df

정정페이지 데이터 수집

import

import pandas as pd
import requests
from bs4 import BeautifulSoup

url 정의 및 호출

query = "삼성전자"
url = f"https://search.naver.com/search.naver?query={query}"

dom = BeautifulSoup(response.text, "html.parser")

정보가져오기

elements = dom.select(".fds-refine-query-grid a")
elements[0].text

element = elements[0]
link = element.get("href")

모집단과 표본

모집단: 우리가 알고 싶은 대상 전체 표본: 그 대상의 일부 영역 -> 표본을 가지고 모집단을 알고 싶은것!

• 우리는 표본을 통해 모집단을 추정한다!

귀무가설 vs 대립가설

• 귀무가설: 기존에 알고있는 가설, 버릴 가설
• 대립가설: 귀무가설에 대립하는 명제

  바이러스 치료제인 A는 효과가 있을까? 귀무가설: A는 효과가 없다. 대립가설: A는 효과가 있다.

그래서 가설 검정이란?

1. 가설을 설립한다.
2. 표본을 통해 P-value를 구한다.
3. P-value의 값이 기준보다 작다면 가설을 수립한다.

-> 이러한 절차를 가설 검정이라 부름

이변량 분석

Case1: 연속 -> 연속

시각화(산점도)

• 두 숫자형 변수의 관계를 나타내는 그래프
• 중요한 관점은 직선인가?

  plt.scatter( x축 값, y축 값 )
  plt.scatter( ‘x변수’, ‘y변수’, data = df) 
  

sns.scatterplot( ‘x변수’, ‘y변수’, data = df) sns.pairplot(dataframe) # 산점도 한번에 그리기

### 수치비교
* 상관계수: 관계를 수치화한것
* 상관분석: 상관계수가 유의미한 지를 검정(test)
```python
import scipy.stats as spst
spst.pearsonr(air['Temp'], air['Ozone'])
# 결과: (상관계수, p-value)

df.corr() # 한번에 상관계수 구하기

-> P-value < 0.05 이면, 두 변수 간에 관계가 있다!

Case2: 범주 -> 연속

시각화

sns.barplot(x="Survived", y="Age", data=titanic)
plt.grid()
plt.show()

• 두 평균에 차이가 크고, 신뢰구간이 겹치지 않을 때

• 대립가설이 맞다!

수치화(t-test, anova(분산분석))

• 범주가 2개 -> t-test
• 범주가 3개 이상 -> anova(분산분석)

# t-test
# 1) t-test를 위한 데이터 준비
# NaN 행 제외
temp = titanic.loc[titanic['Age'].notnull()]
# 두 그룹으로 데이터 저장
died = temp.loc[temp['Survived']==0, 'Age']
survived = temp.loc[temp['Survived']==1, 'Age']
# 2) t-test
spst.ttest_ind(died, survived)


# anova
# 1) 분산 분석을 위한 데이터 만들기
# NaN 행 제외
temp = titanic.loc[titanic['Age'].notnull()]
# 그룹별 저장
P_1 = temp.loc[temp.Pclass == 1, 'Age']
P_2 = temp.loc[temp.Pclass == 2, 'Age']
P_3 = temp.loc[temp.Pclass == 3, 'Age']
# 2) 분산분석
spst.f_oneway(P_1, P_2, P_3)

• p-value가 0.05보다 작으면 차이가 있다.
• t 통계량이 -2보다 작거나, 2보다 크면, 차이가 있다.

Case3: 범주 -> 범주

교차표 사용

# option: columns, index, all
pd.crosstab(행, 열, normalize = option)

시각화(mosaic plot)

mosaic(titanic, [ 'Pclass','Survived'])
plt.axhline(1- titanic['Survived'].mean(),
color = 'r')
plt.show()

수치화(카이제곱검정)

• 기대빈도와 실제의 차이를 값으로 나타낸것

  # 1) 먼저 교차표 집계
  table = pd.crosstab(titanic['Survived’],
  titanic['Pclass'])
  print(table)
  print('-' * 50)
  # 2) 카이제곱검정
  spst.chi2_contingency(table)
  

결과

카이제곱 통계랑, p-value, 자유도, 기대빈도

## Case4: 연속 -> 범주
### 시각화
```python
sns.kdeplot( )

• 주어진 데이터의 구조를 이해하고 분석을 위해 변경하는 과정
• 데이터 분석 절차를 이해하여 데이터를 변경하는 것
• pandas를 활용한다!
  

데이터프레임 변경

열 이름 변경

• 모든 열 이름을 변경하는 방식, 지정한 열 이름을 변경하는 방식이 있음

  df.columns: 모든 열 이름 변경 df.rename(): 지정한 열 이름 변경

tip.columns = ['total_bill', 'tip', 'sex', 'smoker', 'day', 'time', 'size']
tip.rename(columns={'total_bill_amount': 'total_bill',
 'male_female': 'sex',
 'smoke_yes_no': 'smoker',
 'week_name': 'day',
 'dinner_lunch': 'time'}, inplace=True)

열 추가

• 데이터 분석 시 열의 순서가 중요한 경우가 있음! -> 오류발생 가능성이 있음

  없는 열을 변경시 df['new] = []: 맨 뒤에 열 추가 insert(): 지정한 위치에 추가

# final_amt 열 추가
tip['final_amt'] = tip['total_bill'] + tip['tip'] 

# tip 열 앞에 div_tb 열 추가
tip.insert(1, 'div_tb', tip['total_bill'] / tip['size'])

열 삭제

• inplace를 False로 사용 시, 해당 값을 새로운 변수에 저장해야함

  df.drop() axis=0: 행 삭제(기본 값), axis=1: 열 삭제 inplace = False : 삭제한 것처럼 보여줘, True : 원본 데이터 변경

# 열 하나 삭제
tip.drop('final_amt', axis=1, inplace=True)

# 열 두 개 삭제
tip.drop(['div_tb', 'day'], axis=1, inplace=True)

값 변경

• 기본적으로 []을 활용하여 값을 변경할 수 있음

  []: 조건문 사용가능 map: 값에 따라 변경 가능

  # tip[‘tip’] 의 모든 값을 0으로 바꾸기
  tip[‘tip’] = 0
  

tip[‘tip’] 의 값이 10보다 작을 경우, 0으로 바꾸기

tip.loc[tip[‘tip’] < 10, ‘tip’] = 0

tip[‘tip’] 의 값이 10보다 작을 경우 0, 아니면 1로 바꾸기

tip[‘tip’] = np.where(tip[‘tip’] < 10, 0, 1)

Male -> 1, Female -> 0

tip['sex'] = tip['sex'].map({'Male': 1, 'Female': 0})

### pd.cut
* 숫자형 -> 범주형 변수로 변환하는 함수
```python
# 크기로 3등분해서 등급 구하기
tip['tip_grp'] = pd.cut(tip['tip'], 3, labels=['c', 'd', 'e'] )

# 나이를 다음 구간으로 분할합니다.
# 'young'  : =< 40 
# 'junior' : 40 <   =< 50
# 'senior' : 50 < np.inf
# 값의 범위 중 오른쪽(큰값)이 아닌 왼쪽(작은값)이 포함되도록 하려면 pd.cut 함수 옵션에 right = False 라고 지정해야 합니다.
age_group = pd.cut(data2['Age'], bins =[0, 40, 50, 100], labels = ['young','junior','senior'])
age_group.value_counts()

데이터프레임 결합

pd.concat()

• 단순히 합치는 방식
• 행, 열 두 방향 모두 가능!

  axis: 0(세로, 행), 1(가로, 열) 방향으로 합친다 join: outer(모든 행과 열 합치기), inner(같은 행만 합치기)

# 세로로 합치기
pd.concat([df1, df2], axis = 0, join = 'inner')
pd.concat([df1, df2], axis = 0, join = 'outer')

# 가로로 합치기
pd.concat([df1, df2], axis = 1, join = 'inner')
pd.concat([df1, df2], axis = 1, join = 'outer')

inner, outer의 차이

• 기본 데이터
• inner 결과
• outer 결과

pd.merge()

• 지정한 칼럼의 값을 기준으로 병합 / 옆으로만 병합
• 테이블의 조인과 같음!!

  join: outer(모두 합치기), inner(같은 값만 합치기) left : 왼쪽 df는 모두, 오른쪽 df는 같은 값만 right : 오른쪽 df는 모두, 왼쪽 df는 같은 값만 on: 기준 설정

pd.merge(df1, df2, how = 'inner', on = 'A')
pd.merge(df1, df2, how = 'left')
pd.merge(df1, df2, how = 'right')

pd.pivot()

• 집계된(group by) 데이터를 재구성

  temp = pd.merge(sales1, products)
  temp2 = temp.groupby(['Date', 'Category'], as_index = False)['Qty'].sum()
  temp3 = temp2.pivot(index = 'Category', columns = 'Date' , values = 'Qty')

  
  

단변량 분석

• 하나의 변수만을 대상으로 수행하는 데이터 분석 기법
• 데이터를 요약하고 그 변수의 분포나 특성을 이해하는 데 초점
• 숫자형과 범주형에 따라 방식이 다름!

숫자형 단변량 분석

1. 숫자로 요약하기 : 정보의 대푯값
2. 구간을 나누고 빈도수(frequency) 계산 -> 도수 분포표

숫자로 요약하기

np.mean(t['Fare'])
t['Fare'].mean()

np.median(t['Fare'])
t['Fare'].median()

titanic['Pclass'].mode()

# 기초 통계량
df.describe() 

시각화 하기

Histogram

• 도수 분포를 정보 그림으로 나타낸 것
• bins는 구간의 수로 적절히 조절하는 것이 중요

  plt.hist(titanic.Fare, bins = 30, edgecolor = 'gray')
  plt.xlabel('Fare')
  plt.ylabel('Frequency')
  plt.show()

  

Density Plot

• 밀도함수 그래프
• 그래프의 아래 면적의 합은 1

  sns.kdeplot(titanic['Fare'])
  plt.show()

  

Box Plot

• 사전에 반드시 NaN을 제외(sns.boxplot 은 NaN을 알아서 제거해 줌)
• vert 옵션 : 횡(False), 종(True, 기본값)

  plt.boxplot(temp['Age'] , vert = False)
  plt.grid()
  plt.show()

  

범주형 단변량 분석

숫자로 요약하기

titanic['Embarked'].value_counts()
titanic['Embarked'].value_counts(normalize = True)

시각화 하기

Bar Plot

sns.countplot(titanic['Pclass'])
plt.grid()
plt.show()

• 빠른 수치 계산을 위해서 C언어로 만들어진 파이썬 라이브러리
• 벡터와 행렬 연산에 편리한 기능들을 제공
• 데이터분석용 라이브러리인 Pandas와 Matplotlib의 기반으로 사용됨
• Array(벡터, 행렬) 단위로 데이터 관리

용어정리

• Axis: 배열의 각 축(0: 행, 1: 열)
• Rank: 축의 개수(차원)
• Shape: 축의 길이

codes

import

import numpy
import numpy as np
from numpy import array

기본사용

a = np.array()
a.ndim # 차원 출력
a.shape # -> (행, 열)
a.dtype # 데이터 타입 출력

배열 만들기

a = np.array()
a = np.array([1, 2, 3, 4]) # list로 선언
np.zeros((2, 2)) # 0으로 채워진 배열
np.ones((1, 2)) # 1로 채워진 배열
np.full((2, 2), 7.) # 특정 값으로 채워진 배열
np.eye(2) # 단위 행렬(대각만 1)
np.random.random((2, 2))

Reshape

• 기존 배열을 새로운 형태의 배열로 다시 구성하는 함수
• (1, 6) -> (6, 1) 이렇게 변경 가능

  np.reshape(li, (6, 1))
  li.reshape(6, 1)
  li.reshape(6, -1) # -1은 알아서 변환

기본 연산들

a, b

a+b
np.add(a, b)

a-b
np.subtract(a, b)

a*b
np.multiply(a, b)

a/b
np.divide(a, b)

a**b
np.power(a, b)

# 제곱근
np.sqrt(a)

집계 함수들

np.mean(), np.sum(), np.std()
# 전체 집계
print(np.sum(a))

# 열기준 집계
print(np.sum(a, axis = 0))

# 행기준 집계
print(np.sum(a, axis = 1))

# 가장 큰(작은) 값의 인덱스 반환
np.argmax(array, axis=0)
np.argmin(array, axis=0)

배열 데이터 조회: 인덱싱, 슬라이싱

arr1[1, 3]
arr1[1][3]

arr1[1,:] # arr[1]
arr[[행1, 행2]]
arr[[행1, 행2],:] 

arr1[시작:끝]
arr1[행, 시작:끝]
arr1[시작:끝, 시작:끝]

조건에 따른 값 설정

 np.where(조건문, 참일 때 값, 거짓일 때 값)
 np.where(a>2, 1, 0)

What is Pandas?

데이터프레임과 시리즈

데이터프레임(Dataframe)?

• 데이터 분석에서 가장 중요한 데이터 구조
• 관계형 데이터베이스의 테이블 또는 엑셀 시트와 같은 형태 (2차원 구조)
• 변수들의 집합 → 각 열을 변수라고 부름
• 행(분석 단위), 열(정보)

시리즈(Series)?

• 하나의 정보에 대한 데이터들의 집합
• 데이터 프레임에서 하나의 열을 떼어낸 것(1차원)

codes

CSV파일에서 데이터 읽어 오기

• pandas는 여러가지 파일을 읽어오는 것이 가능

  path = './data.csv'
  data = pd.read_csv(path)

데이터프레임 정보 확인

df.head(10) # 상위 10개
df.tail(10) # 하위위 10개

# 열 자료형
data.dtypes

# 모양 확인(행, 열)
df.shape
# 정보 확인
df.info()
# 기초 통계 정보 확인
df.describe()

데이터 정렬

# ascending: False(내림차순), True(오름차순-기본값)
# 인덱스 기준으로 정렬
data.sort_index(ascending=False)
# 정해서 정렬
data.sort_values(by='aaa')
data.sort_values(by=['aaa', 'bbbb'], ascending=[True, True])
temp.reset_index(drop = True)

고유 값 확인

data['MaritalStatus'].unique()
data['MaritalStatus'].value_counts()

기본 집계 메소드

data['MonthlyIncome'].sum()
data['MonthlyIncome'].max()
data[['Age', 'MonthlyIncome']].mean()
data[['Age', 'MonthlyIncome']].median()

데이터조회

• 시리즈와 데이터프레임으로 조회가 가능

  # 1차원(시리즈)로 조회
  data['col']
  data.col
  

2차원(데이터프레임)으로 조회

data[['col']] data[['col1', 'col2']]

### 조건으로 데이터 조회
```python
# 기본 loc[행 조건, 열 이름]
data.loc[data['tip'] > 6.0]

# 여러 조건 and, or -> &, |
data.loc[(data['tip'] > 6.0) | (data['ar'] < 6.0)]]

# 열 이름 지정해서 가져오기
data.loc[:, ['tip', 'size']]

# isin([값1, 값2]): 값이 리스트안에 있어야 조회
tip.loc[tip['day'].isin(['Sat', 'Sun'])]

# between: 사이에 있는 값
# 'left', 'right', 'neither', 'both': 포함 여부
tip.loc[tip['size'].between(1, 3)]
tip.loc[tip['size'].between(1, 3, 'left')]

집계 함수

# MonthlyIncome 합계
data['MonthlyIncome'].sum()

# MonthlyIncome, TotalWorkingYears 각각의 평균
data[['MonthlyIncome', 'TotalWorkingYears']].mean()

max()
min()
count()

groupby()

dataframe.groupby( ‘집계기준변수’, as_index = )[‘집계대상변수’].집계함수

• 집계기준 변수 : ~~별 에 해당되는 변수 혹은 리스트. 범주형 변수 (예: 월 별, 지역 별 등)
• 집계대상 변수 : 집계함수로 집계할 변수 혹은 리스트. (예 : 매출액 합계 )
• as_index = True → 집계기준변수를 인덱스로 사용
• [[tip']].sum() → 결과가 데이터프레임이 됨

# 집계 대상 열을 리스트로 지정
# day별 total_bill, tip 합계 조회
tip.groupby('day', as_index=False)[['total_bill', 'tip']].sum()

# 집계 기준 열을 여럿 설정 가능
# day + smoker별 total_bill, tip 합계 조회
tip.groupby(['day', 'smoker'], as_index=False)[['total_bill', 'tip']].sum()

# agg()
# day별 tip 합계, 평균, 최댓값, 최솟값
tip.groupby('day')['tip'].agg(['sum', 'mean', 'max', 'min'])
# day별 total_bill 평균, tip 합계
tip.groupby('day', as_index=False).agg({'total_bill':'mean', 'tip':'sum'})

• 가장 처음 배우는 만큼 개발자에게 Git은 중요하다.
• Git은 분산 버전관리 시스템
• 프로젝트를 관리하고 협업 시 매우 유용함!!
  

용어정리

기본 개념

Repository(저장소)

• 코드와 관련된 모든 파일과 변경 내역을 저장하는 공간
• 프로젝트의 모든 데이터와 기록이 저장됨

  Commit

• 변경 사항을 저장하는 단위
• 커밋을 통해 파일의 상태를 저장
• 각 커밋은 고유한 해시 값을 가진다.

  Branch

• 독립적으로 작업할 수 있는 가지
• 메인 브랜치와는 별개로 개발하거나 새로운 기능을 추가할 때 사용
• 최종적으로 병합

  HEAD

• 현재 작업 중인 브랜치의 최신 커밋을 가리키는 포인터
• 작업하는 위치를 의미

브랜치 관리 및 협업

Remote(원격 저장소)

• 온라인이나 네트워크 상에 있는 저장소
• GitHub등등

  Merge

• 두 개의 브랜치를 하나로 합치는 작업
• 주로 기능 개발이 완료된 브랜치를 메인 브랜치에 병합

  Clone

• 원격 저장소의 모든 데이터를 로컬로 복사하는 작업

  Pull

• 원격 저장소의 변경 사항을 로컬 저장소로 가져오는 작업
• fetch + merge

  Push

• 로컬에서 작업한 내용을 원격 저장소에 업로드하는 작업

Conflict(충돌)

• 두 브랜치나 커밋을 병합할 때 동일한 파일의 동일한 부분이 다르게 수정된 경우 발생하는 문제
• 수동으로 해결해야함!

  Checkout

• 다른 브랜치로 전환하거나 특정 커밋으로 이동하는 작업
• 특정 브랜치나 커밋으로 작업 디렉토리를 변경

파일 및 변경사항 관리

Stash(임시 저장)

• 현재 작업 중인 변경 사항을 임시로 저장하고, 작업 디렉토리를 깨끗한 상태로 만드는 기능

Fetch

• 원격 저장소에서 변경된 사항을 가져오지만, 자동으로 병합하지는 않음
  

깃 사용 순서

로컬 및 개인 사용시

1. 깃 저장소 생성 / 레포 생성
2. 브랜치 생성
3. 파일 생성
4. 커밋
5. 메인 브랜치에 병합

원격저장소 사용시

1. GitHub등에서 원격저장소 생성
2. 로컬에서 원격저장소 등록
3. pull(fetch+merge)
4. 파일 생성
5. 커밋
6. push

반드시 작업전에 pull을 해야한다!

(추가학습)Git 명령어

기본 설정

저장소 생성 및 파일 추가, 커밋

git init
# 특정 파일 추가
git add user.js
# 현재 폴더를 대상으로 추가
git add .
# add 취소
git reset user.js
# 커밋
git commit -m "Initial commit"

브랜치

# 현재 branch 확인
git branch
# branch 생성
git branch like_feature
# branch 전환
git checkout like_feature

merge

# 원하는 branch로 이동
git checkout master
git merge like_feature

# merge한 branch 확인 후 삭제
git branch --merged
git branch -d like_feature

사용자 정보 설정

lobal user.name "xoo0608"
git config --global user.email xoo0608@gmail.com

# 프로젝트마다 다르도록
git config user.name "ChaneHaDa"
git config user.email chane.ha.da@gmail.com

원격저장소 사용

기본

# 원격 저장소 보기
git remote -v
# 원격 저장소 연결
git remote add origin https://gitlab.com/group/project
# 원격 저장소 확인
git remote

가져오기

# 원격 저장소 복제
git clone https://gitlab.com/alwys/myproject.git
# Pull: 원격 저장소에서 데이터 가져오기 + 병합(Merge)
git pull origin <branch name>
git checkout -t origin/dev # 원격 브런치 가져오기
git checkout -f -t origin/dev
git checkout -b -t origin/dev # 이름바꾸어서 가져오기
# Fetch: 원격 저장소에서 데이터 가져오기 / 작업 후 병합
git fetch

push

# 저장소 발행 / Merge부터 해야함
git push origin master

부트캠프란?

• 개발자를 양성하는 교육 프로그램을 의미함
• 팀 협업을 통한 프로젝트를 수행하며 개발자로 성장하는 교육

  AI 부트캠프 종류

• 대표적으로 3개 정도가 있다.

  카카오테크 부트캠프(인공지능)

  
• 코딩테스트 및 면접 진행
• 약 6개월 진행
• 실시간 온라인 학습
• 오프라인 팀 프로젝트(자체 해커톤)
• 현직자 특강 및 이력서, 포트폴리오 컨설팅

Boostcamp(AI Tech)

• 코딩테스트 및 문제해결력 테스트 진행
• CV(Computer Vision), NLP(Natural Language Processing), RecSys(Recommender System)의 세개의 분야로 나누어서 모집
• 약 7개월 진행
• 도메인 별 학습 후 기업 해커톤 진행
• 취업 간접 지원

KT AIVLE School

• 코딩테스트 및 인적성 검사 진행
• 약 6개월 진행
• 실시간 온라인 학습
• 한 과목마다 미니 프로젝트 이후 빅 프로젝트 진행
• 실제 현업에서 사용하는 방식으로 프로젝트 진행
• AICE 자격증 지원
• 코딩마스터즈 등 역량 강화 프로그램 지원
• 잡페어 및 채용 연계
  

Why AIVLE?

합격 후기

• 사실 위에서 작성한 3개의 부트캠프를 모두 합격하였고 기간이 달라 선택하는 것에 어려움이 있었다.
• 3개의 부트캠프 모두 코딩테스트를 진행하였는데 기초적인 문제를 반드시 해결할 수 있을 것(DFS, BFS 등)이 제일 중요하다고 생각한다.
• 에이블 스쿨의 경우 인적성 검사를 진행한다. 수 많은 기업에서 진행하는 인적성 검사를 경험해 볼 수 있다는 장점이 있다.

AIVLE을 선택한 이유

• 사실 가장 큰 이유는 KT의 채용연계 이 부분이다. 잡페어 및 기타 채용 지원 부분에서 AIVLE만한 곳이 없었다.
• 또한, 백엔드 개발자를 희망하기도 하여서 AI 모델링 및 웹서비스 개발을 모두 경험할 수 있다는 점에서 크게 장점이 있었다.

AIVLE 합류 과정

1. 내일 배움 카드 발급 및 수령
2. HRD-Net 온라인 수강 신청
3. AIVLE 아이디 발급
4. 파이썬 및 시각화 사전교육(선택사항)
5. 노트북 수령(분당 kt 본사)
6. 교육 시작
   

끝마치면서

백엔드 개발자로 꾸준히 학습을 진행하고 있었지만 AI에 대한 이해는 필수적으로 필요하다고 생각한다. 혼자서 공부하기 힘든 부분이 있기 때문에 KT AIVLE School을 통해서 학습해보고자 한다. 다음에는 배운 것을 토대로 글을 작성하겠다~!

• 데이터 모델링에서 사용되는 객체
• 데이터 베이스 테이블
  

What is Repository

• 데이터 베이스 테이블에 접근하기 위해 사용하는 인터페이스
• 실제로 DB에 접근하는 객체
  

Entity

기본 코드

@Entity
@Table(name = "PERSON", uniqueConstraints = {
        @UniqueConstraint(name = "NAME_AGE_UNIQUE", columnNames = {"NAME", "AGE"})
}) //제약조건 설정
@Access(AccessType.FIELD) // 직적 접근 -> if @Id 가 있으면
@Access(AccessType.PROPERTY) //getter 사용 
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO) 
    //IDENTITY, SEQUENCE, TABLE, AUTO(자동으로 선택)
    private Long id;
    private String name

    @Enumerated(EnumType.STRING) //Enum의 이름값 저장
    //@Enumerated(EnumType.ORDINAL) //Enum의 순서 저장
    private String role;

    @Transient // 매핑을 하지 않음
    private String description;

    @Temporal(TemporalType.DATE) //날짜
    @Temporal(TemporalType.TIME) //시간
    @Temporal(TemporalType.TIMESTAMP) //날짜 + 시간
      private Date regDate;

      @Column(unique = true)
      @Column(columnDefinition = "varchar(100) default 'EMPTY'")
      @Column(nullable = false)
      @Column(length = 400)
      @Column(precision = 10, scale = 2) //precision, 자릿수 / scale, 소수점 
}

• 기본 생성자는 필수이다.

클래스 어노테이션 정리

• @Entity: 엔티티임을 선언

• @Table: 테이블의 이름과 제약조건을 설정할 수 있음

• @UniqueConstraint: 제약 조건을 설정

• @Access: 접근 방식 설정

• AccessType.FIELD: 직접 접근

• AccessType.PROPERTY: getter 사용해서 접근

  AccessType.PROPERTY

  @Entity
  @Access(AccessType.FIELD) // 직적 접근 -> if @Id 가 있으면
  @Access(AccessType.PROPERTY) //getter 사용 
  public class Person {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO) 
     private Long id;
  
     @Transient
     private String firstName;
  
     @Transient
     private String lastName;
  
       @Access(AccessType.PROPERTY)
       public String getFullName() {
           return firstName + lastName;
       }
  

}

* 다음과 같은 방식으로 Getter를 이용하여 접근

### 변수 어노테이션 정리
* @Id: 기본키(Primary key)를 설정
* @GeneratedValue(strategy = GenerationType.AUTO): 기본키를 조건에 따라 자동으로 생성함
* @Enumerated: Enum 사용을 위한 것
-> EnumType.STRING: 이름값 저장
-> EnumType.ORDINAL: 순서 저장
* @Transient: 매핑을 하지 않음, 테이블에 저장 X
* @Temporal:날짜 타입 지정
* @Column: 컬럼 지정
<br/>

# Repository
```java
public interface PersonRepository extends JpaRepository<Person, Long> {
}

• 다음과 같이 선언이 가능하다.

• JPA는 Java Persistence API의 약자로 자바 진영에서 ORM 기술 표준으로 사용 되는 인터페이스의 모음

ORM?

• Object-Relational Mapping의 약자로 Class와 테이블을 매핑하는 기술
• 객체를 RDB의 테이블에 연결해주는 기술
• SQL을 작성하지 않고 DB를 조작하여 비즈니스 로직에 집중 할 수 있음

JPA와 Hibernate, JDBC

JDBC

• Java Database Connectivity의 약자
• Java에서 DB에 접근할 수 있도록 제공하는 API
• 영속성 레이어를 만들기 위한 것

• 데이터를 생성한 프로그램이 종료되어도 존재하기 위함

Hibernate

• JPA는 인터페이스를 구현하여 사용해야함
• Hibernate는 JPA의 구현체 중 하나

• 분산된 메시지를 추적하는 방식
• 여러개의 서비스들의 호출등을 추적하는 방식
  

Zipkin 사용하기

• docker을 사용해서 실행하였다.

    docker run -p 9411:9411 --rm openzipkin/zipkin

  
  

Client 설정하기

dependencies

dependencies {
    implementation 'io.micrometer:micrometer-observation'
    implementation 'io.micrometer:micrometer-tracing-bridge-otel'
    implementation 'io.opentelemetry:opentelemetry-exporter-zipkin'

    //Brave as Bridge
    implementation 'io.micrometer:micrometer-tracing-bridge-brave'
    implementation 'io.zipkin.reporter2:zipkin-reporter-brave'

    //Uses Feign
    implementation 'io.github.openfeign:feign-micrometer'
}

설정하기

management.tracing.sampling.probability=1.0
logging.pattern.level=%5p [${spring.application.name:},%X{traceId:-},%X{spanId:-}]

• 샘필링할 확률을 설정 1.0은 모두 출력함
• logging.pattern.level 로그의 패턴을 설정
  

• 서비스 호출에서 장애가 발생하면 다른 서비스로 장애가 전파된다.
• 요청이 계속 쌓이다 보면 복구가 어렵다.
• 장애가 발생한 서비스를 탐지하고, 요청을 보내지 않도록 차단하는 디자인 패턴이 Circuit Breaker이다.
  

Use

dependencies

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-aop'
    implementation 'io.github.resilience4j:resilience4j-spring-boot3'
}

• 쉬운 적용을 위해서 aop를 추가적으로 사용하는 것이 좋다.

설정하기

• application.properties

  resilience4j.retry.instances.sample-api.maxAttempts=5
  resilience4j.retry.instances.sample-api.waitDuration=1s
  resilience4j.retry.instances.sample-api.enableExponentialBackoff=true
  

#resilience4j.circuitbreaker.instances.default.failureRateThreshold=90

resilience4j.ratelimiter.instances.default.limitForPeriod=2 resilience4j.ratelimiter.instances.default.limitRefreshPeriod=10s

resilience4j.bulkhead.instances.default.maxConcurrentCalls=10 resilience4j.bulkhead.instances.sample-api.maxConcurrentCalls=10

* maxAttempts: 재시도 방식의 최대 시도횟수를 정한다.
* waitDuration: 기다리는 시간 설정
* enableExponentialBackoff: 재요청 시간 간격 점차 증가

### Code
* Controller.java
```java
@RestController
public class CircuitBreakerController {

    private Logger logger =
            LoggerFactory.getLogger(CircuitBreakerController.class);

    @GetMapping("/sample-api")
    //@Retry(name = "sample-api", fallbackMethod = "hardcodedResponse")
    //@CircuitBreaker(name = "default", fallbackMethod = "hardcodedResponse")
    //@RateLimiter(name="default")
    @Bulkhead(name="sample-api")
    //10s => 10000 calls to the sample api
    public String sampleApi() {
        logger.info("Sample api call received");
//        ResponseEntity<String> forEntity = new RestTemplate().getForEntity("http://localhost:8080/some-dummy-url",
//                    String.class);
//        return forEntity.getBody();
        return "sample-api";
    }

    public String hardcodedResponse(Exception ex) {
        return "fallback-response";
    }
}

• @Retry: 오류 발생시 재시작
• @CircuitBreaker: 지정한 실패률 초과시 차단
• @RateLimiter: 초당 허용하는 건수 설정
• @Bulkhead: 동시 호출을 수를 제한하는 방식
• fallbackMethod: 예비로 실행할 함수, 기본 함수와 리턴 값이 같아야한다.

• API들은 REST 방식을 이용하여 호출한다.
• 각 서비스별로 Swagger를 적용하여서 문서화 하였다.
• Gateway를 활용해서 통합 문서를 사용하자
  

In Gateway

dependencies

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    implementation 'org.springdoc:springdoc-openapi-starter-webflux-ui:2.4.0'
}

• Gateway는 webflux 방식이기 때문에 위와 같이 추가해야한다.

설정하기

• application.properties

  springdoc.swagger-ui.use-root-path=true
  

springdoc.swagger-ui.urls[0].name=securities-service springdoc.swagger-ui.urls[0].url=http://localhost:8765/api/securities-service/v3/api-docs

* springdoc.swagger-ui.use-root-path: 루트 접근 시 swagger 페이지로 이동한다.
* springdoc.swagger-ui.urls[0].name: 서비스 이름 지정
* springdoc.swagger-ui.urls[0].url: 서비스의 정보 URL

### Gateway 설정
* ApiGateWayConfig.java
```java
@Configuration
public class ApiGateWayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder routeBuilder) {
        return routeBuilder.routes()
                .route("securities-service-openapi", r -> {
                    return r.path("/api/securities-service/v3/api-docs/**")
                            .filters(f -> f.rewritePath(
                                    "/api/securities-service/(?<path>.*)", "/${path}"))
                            .uri("lb://SECURITIES-SERVICE");
                })
                .route("securities-service", r -> {
                    return r.path("/stockprice/**", "/stockinfo/**")
                            .uri("lb://SECURITIES-SERVICE");
                })
                .build();
    }
}

• 위의 라우터는 사용자의 요청을 문서에 접근하게 하기 위해서
• 밑의 라우터는 사용자의 API 호출을 처리하기 위해서
  

Client

Swagger config

• SwaggerConfig.java

  @Configuration
  public class SwaggerConfig {
    @Bean
    public OpenAPI openAPI() {
        return new OpenAPI()
                .components(new Components())
                .addServersItem(new Server().url("/"))
                .info(apiInfo());
    }
  
    private Info apiInfo() {
        return new Info()
                .title("Securities service")
                .description("Stock information service")
                .version("1.0.0");
    }
  }
  

```

• Spring Cloud Gateway는 API Gateway를 제공
• API들의 단일지점을 제공
• API들에 공통된 작업을 수행할 수 있음(Filter)
• 로깅, 모니터링 가능
  

USE

• Eureka 서버를 같이 사용함

  dependencies

  dependencies {
    implementation 'org.springframework.cloud:spring-cloud-starter-gateway'
    implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
  }

  설정하기

• application.properties

  spring.application.name=api-gateway
  server.port=8765
  

eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka

spring.cloud.gateway.discovery.locator.enabled=true spring.cloud.gateway.discovery.locator.lower-case-service-id=true

* 이제 다음과 같이 localhost:8765/SERVICE-NAME을 통해서 접근이 가능하다.
* spring.cloud.gateway.discovery.locator.lower-case-service-id 다음 설정을 통해 소문자의 경우도 접근이 가능하다.

### 좀 더 설정하기
* ApiGatewayConfiguration.java
```java
@Configuration
public class ApiGatewayConfiguration {

    @Bean
    public RouteLocator gatewayRouter(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(p -> p
                        .path("/get")
                        .filters(f -> f
                                .addRequestHeader("MyHeader", "MyURI")
                                .addRequestParameter("Param", "MyValue"))
                        .uri("http://httpbin.org:80"))
                .route(p -> p.path("/currency-exchange/**")
                        .uri("lb://currency-exchange"))
                .route(p -> p.path("/currency-conversion/**")
                        .uri("lb://currency-conversion"))
                .route(p -> p.path("/currency-conversion-feign/**")
                        .uri("lb://currency-conversion"))
                .route(p -> p.path("/currency-conversion-new/**")
                        .filters(f -> f.rewritePath(
                                "/currency-conversion-new/(?<segment>.*)",
                                "/currency-conversion-feign/${segment}"))
                        .uri("lb://currency-conversion"))
                .build();
    }
}

• 다음과 같은 route를 통해 사용자의 요청을 라우팅 할 수있다.
• filter를 적용하여 작업을 수행할 수 있다.
• rewritePathsms 사용자의 요청을 변환한다.
  

• MSA에서 서비스간 호출이 필요한 경우가 많다.
• 서비스간 호출을 위해서는 IP등의 정보를 가지고 있어야 한다.
• 서비스 호출에 필요한 정보를 저장하고 도움을 주는 것이 Eureka Server
• 로드밸런싱의 기능도 지원한다.
  

Server 사용하기

dependencies

implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-server'

Application.java

@EnableEurekaServer
@SpringBootApplication
class NamingServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(NamingServerApplication.class, args);
    }

}

• @EnableEurekaServer 다음의 어노테이션을 추가해야한다.

설정

• application.properties

  spring.application.name=naming-server
  server.port=8761
  

eureka.client.register-with-eureka=false # 자신을 등록할지 eureka.client.fetch-registry=false # 레지스트리에 정보를 가져올지

디버깅에 유용함

eureka.instance.prefer-ip-address=true eureka.instance.hostname=localhost

<br/>

# Client 사용하기
### dependencies
```gradle
implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'

설정

• application.properties

  eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka

• 기본적으로 알아서 등록한다.

Feign 사용시

@FeignClient(name="my-service")

• 다음과 같이 서비스명으로 접근이 가능하다.
  

• 인터페이스와 어노테이션 기반으로 REST 호출이 가능
• Eureka등의 다른 기술들과 통합 가능
• 서비스간 호출을 위해서 사용

  단점 및 한계

• Http2를 지원하지 않음
• 공식적으로 Reactive 모델을 지원하지 않음
  

사용하기

dependencies

implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'

Application.java

@SpringBootApplication
@EnableFeignClients
public class ServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class, args);
    }

}

• @EnableFeignClients 다음의 어노테이션의 추가가 필요하다.

Proxy interface

@FeignClient(name="restservice", url="localhost:8000")
public interface RestProxy {
    @GetMapping("/team")
    public NewTeam hello();
}

• 다음과 같이 restservice의 서비스를 가져와서 사용할 수 있다.
• Eureka를 적용하면 url을 사용하지 않아도 호출이 가능하다.

Use

@RestController
public class Controller {
    @Autowired
    private RestProxy restProxy;

    @GetMapping("/myteam")
    public NewTeam retrieveMyTeam() {
        NewTeam team = restProxy.hello();
        return team;
    }
}