vel1024

Circular Dependency

vel1024 — Fri, 17 Sep 2021 16:25:59 +0900

토이 프로젝트 하면서 다음과 같은 문제가 생겼었다

spring security 를 도입하면서 UserDetailsService 인터페이스를 상속받아서

loadUserByUsername 을 오버라이드 해야 했는데 그 과정에서 다음과 같은 에러가 났었다.

- Circular Dependency

: 순환 종속, Spring 의 Bean 이 어떤 다른 Bean 에 대해서 의존성 주입을 받을 때 서로가 서로를 의존성 주입하는 과정에서 발생하는 에러이다.

만약 Bean A, B 가 있다고 했을때

Bean A 가 B 를 의존성 주입 받고, B가 A 를 의존성 주입받으면 이런 문제가 발생한다

- 스프링 내부 작업

Spring Context 가 실행되고 Bean 들을 생성할때 다음과 같은 순서로 생성한다

예를들어 (순환 종속성이 없다는 가정하에)

Bean A -> Bean B -> Bean C

(Bean A 가 B 를 의존성 주입 받은 상태고, B 가 C 를 의존성 주입 받은 상태라 할때)

먼저 아무런 의존성 주입을 받지 않고 존재하는 C 를 먼저 생성하고

그 다음 B 를 생성한 뒤에 C 를 B 에 의존성 주입 시키고

그 다음 A 를 생성한 뒤에 B 를 A 에 의존성 주입 시키는 순서를 가지며 Bean 을 생성한다

그래서 순환 종속성 상황이 되었다면 Spring 이 어떤 Bean 을 먼저 생성해야 하는지 결정하지 못하고

BeanCurrentlyInCreationException 에러가 뜨는 것이다.

- 해결책

1. 재설계

가장 좋은 해결책은 Bean 들의 의존성 관계를 분석해보고

어떻게 하면 상호간의 의존성 관계를 해소할 수 있는지 찾아내서

다시 설계 하는게 가장 좋은 방법이다

예를들어 내가 마주한 문제에선 코드를 다음과 같이 개선해보려했다

* 문제가 생겼던 코드

- WebSecurity.java

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurity extends WebSecurityConfigurerAdapter {
 
    private final UserService userService;
 
    // 나머지 생략...
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService).passwordEncoder(bCryptPasswordEncoder());
    }
 
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
Colored by Color Scripter

cs

- UserService.java

public interface UserService extends UserDetailsService {
    // 기타 메소드 생략...
}
Colored by Color Scripter

cs

- UserServiceImpl.java

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
 
    private final UserRepository userRepository;
    private final BCryptPasswordEncoder bCryptPasswordEncoder;
 
    // 기타 메소드 생략 ......
 
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(username);
 
        if (user == null)
            throw new UserServiceException("user not exist !");
 
        return new org.springframework.security.core.userdetails.User(
                user.getEmail(),
                user.getEncryptedPwd(),
                true,
                true,
                true,
                true,
                new ArrayList<>()
        );
    }
}
Colored by Color Scripter

cs

이 코드들의 문제점은

먼저 AuthenticationManagerBuilder 에 userDetailsService 를 제시해줘야하고

이에 대한 처리를 위해 UserService 가 UserDetailsService 를 상속 받아서

UserServiceImpl 클래스에서 loadUserByUsername 을 재정의 하였는데

회원가입시에 비밀번호 암호화 처리를 위해 BCryptPasswordEncoder 를 Bean 으로 등록해서 사용해야 했었다

그렇게 되다 보니 UserService 는 BCryptPasswordEncoder 를 위해서 WebSecurity 를 참조하게 되었고

WebSecurity 는 userDetailsService 를 위해서 UserService 를 참조해야 했다

즉, 앞서 말한 Circular Dependency 문제가 생긴것이다.

그래서 이 문제 해결을 위해서 UserDetailsService 를 UserService 에서 상속 받지 말고

별도의 클래스를 만들어서 거기서 구현하도록 분할하려고 하였다.

* 문제를 해결한 코드

- UserDetailsServiceImpl.java

@Service
@RequiredArgsConstructor
public class UserDetailsServiceImpl implements UserDetailsService {
 
    private final UserRepository userRepository;
 
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(username);
 
        if (user == null)
            throw new UserServiceException("user not exist !");
 
        return new org.springframework.security.core.userdetails.User(
                user.getEmail(),
                user.getEncryptedPwd(),
                true,
                true,
                true,
                true,
                new ArrayList<>()
        );
    }
}
 
Colored by Color Scripter

cs

- WebSecurity.java

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurity extends WebSecurityConfigurerAdapter {
 
    private final UserDetailsServiceImpl userDetailsServiceImpl;
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsServiceImpl).passwordEncoder(bCryptPasswordEncoder());
    }
 
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
 
Colored by Color Scripter

cs

- UserService.java

public interface UserService {
}

cs

- UserServiceImpl.java

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
 
    private final UserRepository userRepository;
    private final BCryptPasswordEncoder bCryptPasswordEncoder;
 
    // 기타 메소드 생략 ....
}
Colored by Color Scripter

cs

이런식으로 분할해서 처리를 해줌으로써 순환종속 문제를 해결할 수 있었다.

2. @Lazy

또 다른 해결책으로는 @Lazy 를 쓰는 방법이 있다.

가장 좋은 해결책은 사실 재설계를 하는 것이나 부득이한 이유로 그럴 수 없는 경우

임시 방편 정도의 해결책이라 생각하면 될 것 같다.

- 예시 코드 (출처 : https://www.baeldung.com/circular-dependencies-in-spring)

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public CircularDependencyA(@Lazy CircularDependencyB circB) {
        this.circB = circB;
    }
}
Colored by Color Scripter

cs

최초에 Bean 을 초기화할때 앞서서 말한 순차적인 순서대로 생성하는게 아니라

프록시를 따로 만들고 나중에 필요할때 주입하는 형식이다.

3. @PostConstruct

@Autowired 로 의존성 주입해놓은 경우 @PostConstruct 를 쓰면 문제를 해결 할 수 있다

- 코드 예시(출처 : https://www.baeldung.com/circular-dependencies-in-spring)

@Component
public class CircularDependencyA {
 
    @Autowired
    private CircularDependencyB circB;
 
    @PostConstruct
    public void init() {
        circB.setCircA(this);
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}
Colored by Color Scripter

cs

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
    
    private String message = "Hi!";
 
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
    
    public String getMessage() {
        return message;
    }
}
Colored by Color Scripter

cs

4. Setter

생성자를 통한 의존성 주입 말고 Setter 를 통한 의존성 주입을 하게 되면

필요한 시점이 아닌 순간이 되기 전엔 의존성 주입을 받지 않게 된다

- 코드 예시 (출처 : https://www.baeldung.com/circular-dependencies-in-spring)

@Component
public class CircularDependencyA {
 
    private CircularDependencyB circB;
 
    @Autowired
    public void setCircB(CircularDependencyB circB) {
        this.circB = circB;
    }
 
    public CircularDependencyB getCircB() {
        return circB;
    }
}
Colored by Color Scripter

cs

@Component
public class CircularDependencyB {
 
    private CircularDependencyA circA;
 
    private String message = "Hi!";
 
    @Autowired
    public void setCircA(CircularDependencyA circA) {
        this.circA = circA;
    }
 
    public String getMessage() {
        return message;
    }
}
Colored by Color Scripter

cs

- Reference

https://www.baeldung.com/circular-dependencies-in-spring

직렬화

vel1024 — Wed, 15 Sep 2021 22:12:10 +0900

그냥 막연하게만 직렬화가 클래스를 바이트 형태로 바꾸는거다 (역직렬화는 그 반대) 정도로만 알고 있었는데

막상 면접때 말하려니 왜 쓰는지도 모르고 그냥 추상적이게 말하니

허접하게 대답할 수 밖에 없었고 당연히 좋은 결과를 얻을 수도 없었다

그래서 한번 정리를 해보고자 포스팅을 남겼다

- 가상메모리주소공간

운영체제에서 메모리 용량보다 큰 프로세스에 대해서 처리를 할 때 사용하는게 가상 메모리인데, 서로 다른 운영체제 마다 가상메모리를 다르게 갖기 때문에 Object 같은 타입의 참조값(주소값) 데이터는 다른 운영체제에 전달해봐도 그 의미가 없어진다.

그래서 메모리 참조하는게 아니라 Byte 형태로 변환된 데이터를 전달하게 되면, 가상메모리 문제를 신경쓰지 않고 참조형 데이터에 대한 처리를 할 수 있게 된다.

그래서 직렬화가 필요하고 여태까지 알고 있었던 자바 직렬화 말고도 JSON, CSV, XML 등 여러 데이터 포맷에 대한 직렬화/역직렬화가 가능하다

- 자바 직렬화가 아닌 다른 데이터 포맷에 대한 직렬화

: 앞서 말한 CSV, JSON 등의 자바가 아닌 다른 데이터 포맷은 자바에서 구현하려면 외부 라이브러리를 차용해야 한다

CSV 는 , 로 데이터를 구분하고 표 형태의 다량 데이터를 다룰 때 사용되는 포맷이며, Apache Common CSV, opencsv 등이 사용된다.

JSON 은 구조화된 데이터로 사용되고 자바에선 Jackson 등을 사용한다

또한 이진 직렬화 방법이라 해서 데이터 변환이나 전송속도에 최적화되어서 직렬화 방법을 제시하는 Protocol Buffer, Apache Avro 등이 있다 이런식의 직렬화 방식은 특정 플랫폼이나 언어에 종속되지 않는다는 장점을 갖는다.

- 자바 직렬화

자바 직렬화는 이름에서 알 수 있듯 자바 환경에 최적화되어서 만들어진 직렬화 방식이다

자바 직렬화에서 갖춰야할 기본조건만 갖추면 손쉽게 직렬화를 할 수 있고 복잡한 데이터 구조를 갖고 있더라도 많은 작업 없이 직렬화/역직렬화를 할 수 있다는 장점이 있다

자바에서 보통 JSON 이나 CSV 등과 같은 다른 데이터 포맷을 통한 직렬화 보다는 자바 직렬화를 쓰는 이유는 자바 직렬화가 갖는 위와 같은 장점때문이다.

- 자바 직렬화를 쓰는 경우

JVM 메모리에만 있던 객체 데이터에 영속성을 부여하고 싶을때 사용해서 네트워크로 전송시에 사용된다

실질적인 사용 예시를 들면

1) Servlet Session

Servlet 기반의 WAS (톰캣 등) 는 대부분 세션의 자바 직렬화를 지원하고 이 세션 자체를 파일로 저장하거나 세션 클러스터링을 하거나 DB 에 저장하거나 하는 등 할때 세션 자체를 직렬화해서 사용한다

2) Cache

Redis, Memcached 같은 시스템을 사용할때 사용된다

캐시란 그 특성상 자주 쓰이는 것들을 담아둬서 더 빠르게 처리하는 것을 목표로 하는 것 처럼

예를들어 DB 에서 뭔가를 가져와서 처리를 해야할때 동일한 것을 반복적으로 가져오는 경우 DB 에 보낼 요청이 시간이 오래 소요되므로 redis 같은 캐시 서버를 운용하고 이 캐시 시스템에 객체를 담을때 직렬화를 한다

- 자바 직렬화의 조건

자바에서 직렬화를 하기 위해선 primitive type 의 경우 이미 그자체로 byte 단위이므로 아무 조건이 없지만

객체 같은 참조형 데이터는 java.io.Serializable 인터페이스를 구현해야한다

(객체는 그 크기가 가변적이고 또 앞서 말한것 처럼 참조형 데이터이므로 다른 OS 에서 가상 메모리 문제 때문에)

하지만 객체의 멤버 중 Transient 가 선언된 케이스는 직렬화 대상에서 제외된다

역직렬화의 경우 직렬화 대상이된 클래스가 ClassPath 에 있어야 한다

(ClassPath 는 .java 파일을 컴파일한 바이트 코드 .class 파일이 담긴 위치를 의미함)

- 예시 (코드 출처 : https://techblog.woowahan.com/2551/)

- Member.java

import java.io.Serializable;
 
public class Member implements Serializable {
    private static final long serialVersionUID = 1L;
 
    private final String name;
    private final String email;
    private final Integer age;
 
    public Member(String name, String email, Integer age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }
 
    // Getter, toString 생략됨
}
 
Colored by Color Scripter

cs

- DeSerializableMain.java

import java.io.*;
import java.util.Base64;
 
public class DeSerializableMain {
    public static void main(String[] args) {
        Member member = new Member("park", "test@test.com", 20);
 
        byte[] serializedMember = null;
 
        try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream)) {
                objectOutputStream.writeObject(member);
                serializedMember = byteArrayOutputStream.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        String base64Member = Base64.getEncoder().encodeToString(serializedMember);
 
        System.out.println(base64Member);
 
        byte[] deSerializedMember = Base64.getDecoder().decode(base64Member);
 
        try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(deSerializedMember)) {
            try (ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream)) {
                Object objectMember = objectInputStream.readObject();
                Member deMember = (Member) objectMember;
                System.out.println(deMember);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 
Colored by Color Scripter

cs

- 출력

(직렬화된 Byte 배열 코드를 Base64 인코더로 출력한 String 값과 다시 역직렬화를 통해 얻어온 member 인스턴스의 toString 값)

- serialVersionUID (SUID)

: SUID 값은 사실 위에처럼 직접 선언하지 않아도 클래스 구조 정보를 이용해서 SHA-1 을 이용한 해시값을 기반으로 만들어진다

그럼에도 직접 선언해서 관리를 해야하는 이유는

자바 클래스의 정보가 바뀌면 serialVersionUID 값도 달라지기 때문이다

같은 클래스라도 serialVersionUID 값이 다르면 에러가 발생하게 된다

또한 멤버 변수의 타입이 바뀌는 경우에도 에러가 나므로 주의해야한다

(멤버 변수를 제거하거나 변수명을 바꾸면 에러는 안나지만 데이터가 누락된다)

- 그렇다면 자바 직렬화는 어떻게 써야 하고 언제 써야 하는가

1) serialVersionUID 값을 직접 관리해라

2) 멤버변수 타입은 바꾸지 말아라

3) 외부 (DB, Cache 등) 에 장기간 저장될 정보는 자바 직렬화 쓰지 말아라

-> 언제 클래스 정보가 바뀔지 모르기 때문

4) 자바 직렬화는 클래스에 대한 메타정보를 가지고 있어서 용량이 JSON 같은 포맷에 비해서 크므로 Redis 같은 메모리 서버에 저장할때 용량 문제에 신경써야 한다

5) 개발자가 직접 컨트롤하기 힘든 클래스(라이브러리나 프레임워크가 제공하는 것들)은 자바 직렬화 하지 말아라

6) 역직렬화시에 예외가 발생할 가능성이 있으므로 예외처리를 해줘야한다

다시 느끼지만 그냥 엉성하게 알고 대충 지나가면

항상 나중에 꼭 피보는거 같다

오늘 편하자고 대충 넘기면 꼭 나중에 다시 돌아오는듯

- References

1. https://techblog.woowahan.com/2550/

2. https://techblog.woowahan.com/2551/

Spring Boot 2.5 이후 버전과 Hibernate 와 data.sql

vel1024 — Wed, 15 Sep 2021 13:14:36 +0900

Spring Cloud 강의를 들으면서 H2 데이터베이스와 Spring Data JPA 를 사용했는데

미리 넣어둘 데이터를 data.sql 에 정의해두고 테이블 생성은 Hibernate 에 의해서 하도록 하려고 하였으나

테이블이 생성되지 않고 에러가 났다.

결론부터 말하면

application.yml 에 다음의 요소를 추가하면 에러가 해결된다

spring.jpa.defer-datasource-initialization: true

cs

2.5 이후 다음과 같은 내용이 추가되었다

Hibernate and data.sql
By default, data.sql scripts are now run before Hibernate is initialized. This aligns the behavior of basic script-based initialization with that of Flyway and Liquibase. If you want to use data.sql to populate a schema created by Hibernate, set spring.jpa.defer-datasource-initialization to true. While mixing database initialization technologies is not recommended, this will also allow you to use a schema.sql script to build upon a Hibernate-created schema before it’s populated via data.sql.

Hibernate 가 테이블을 만들기 이전에 data.sql 이 먼저 실행되도록 바뀐것 같다

Flyway 와 Liquibase 가 아직은 뭔지는 모르겠으나 이것과 일치시키기 위해서 바뀌었다고 하는것 같다

그래서 Hibernate 가 먼저 테이블을 만들게 하고 싶으면 spring.jpa.defer-datasource-initialization 을 true 하라는 내용이 있다.

또 Hibernate 대신에 schema.sql 을 직접 작성해서 스키마를 만드는 방법도 있는듯하다

Spring Cloud Eureka 와 기본 REST API

vel1024 — Tue, 14 Sep 2021 19:43:23 +0900

간단한 토이 프로젝트를 만들다가 여러번 동일한 서비스의 eureka client instance 를 만든적이 있는데,

아무리 시간이 지나도 service discovery 에서 제거되지 않고 남아있어서

언제 지워지는지 그리고 어떻게 수동으로 지우는지를 알아보고자 찾아본 내용을 기록했다.

- Eureka

: eureka 는 MSA 에서 service 의 로드 밸런싱이나 실패 처리 등을 유연하게 처리하기 위해서 ip, port, instance id 등을 가지고 있는 미들웨어 서버를 의미한다

MSA 에서는 ip 나 port 가 항상 가변적이기 때문에 이들에 대한 주기적인 관리가 필요한데, 이를 관리하는 것이 MSA 에서 Service Discovery 이며 spring 에선 이를 spring cloud netflix eureka 를 이용해서 처리한다

Eureka 는 Client-Server 방식을 사용하고 Eureka Server 가 다른 모든 Eureka Client 들을 관리하는 역할을 담당한다

기본적으로 Eureka Client 와 Eureka Server 간의 통신은 REST API 를 통해서 이뤄지고 기본적인 API 들은 다음과 같다

* appID 는 등록하려는 MSA 서비스 이름, instanceID 는 해당 서비스중 특정 instance 의 ID 값을 의미한다

- Register

POST /eureka/apps/{appID}

Eureka Client 를 Eureka Server 에 등록할때 사용된다

(예시)

http://localhost:8761/eureka/apps/test-service
 
{
  "instance": {
    "instanceId": "392d9569-3a3a-4da0-9447-bfdcc14d8b30",
    "hostName": "x.x.x.x",
    "app": "test-service",
    "ipAddr": "x.x.x.x",
    "status": "UP",
    "overriddenStatus": "UNKNOWN",
    "port": {
      "$": 8081,
      "@enabled": "true"
    },
    "securePort": {
      "$": 443,
      "@enabled": "false"
    },
    "countryId": 1,
    "dataCenterInfo": {
      "@class": "com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo",
      "name": "MyOwn"
    },
    "leaseInfo": {
      "renewalIntervalInSecs": 30,
      "durationInSecs": 90,
      "registrationTimestamp": 0,
      "lastRenewalTimestamp": 0,
      "evictionTimestamp": 0,
      "serviceUpTimestamp": 0
    },
    "metadata": {
      "@class": "java.util.Collections$EmptyMap"
    },
    "homePageUrl": "http://192.168.4.91:8081/",
    "statusPageUrl": "http://192.168.4.91:8081/actuator/info",
    "healthCheckUrl": "http://192.168.4.91:8081/actuator/health",
    "vipAddress": "test-service",
    "secureVipAddress": "test-service",
    "isCoordinatingDiscoveryServer": "false",
    "lastUpdatedTimestamp": "1580878819825",
    "lastDirtyTimestamp": "1580878820311"
  }
}
Colored by Color Scripter

cs

- Renew

: Eureka Client 는 기본적으로 30초를 주기로 Eureka Server 에게 HeartBeat 를 보낸다

서버가 만약 90초 동안 HeartBeat 를 받지 못하면 Server 정보 저장소에서 해당 Client 의 인스턴스가 제거된다

(클라이언트 인스턴스 정보를 보면 leaseInfo 라는 부분에서 그 시간을 알 수 있다)

Renew 는 Client 가 Server에게 HeartBeat 를 보내는 REST API 를 말한다

PUT /eureka/apps/appID/instanceID

(예시)

PUT /eureka/apps/test-service/392d9569-3a3a-4da0-9447-bfdcc14d8b30?status=UP&lastDirtyTimestamp=1580878820311

cs

- Fetch Registry

: Eureka Client 는 Server 가 가동될때 Eureka Server 에 있는 모든 정보를 가져와서 local cache 에 저장한다

그리고 이 정보를 이용해서 http 통신에 사용한다

이 정보는 30초 마다 변경점에 대해서 부분 업데이트를 진행한다

처음에 모든 정보를 다 요청할때는

GET /eureka/apps

GET /eureka/apps

cs

30 초에 한번씩 변경된 정보를 가져올때는

GET /eureka/apps/delta

GET /eureka/apps/delta

cs

이에 대한 응답은 다음과 같다

(예시)

{
  "applications": {
    "versions__delta": "21",
    "apps__hashcode": "UP_2_",
    "application": [
      {
        "name": "test-service",
        "instance": [
          {
            ...
            "status": "UP",
            ...
          },
          {
            ...
            "status": "DOWN",
            ...
          }
        ]
      }
    ]
  }
}

cs

UP 은 실행되고 있는 인스턴스, DOWN 은 사용되지 않는 죽은 서버를 의미한다

delta 요청을 통해서 죽은 서버를 가져오게 되면 client 는 자신이 가진 local cache 에서 해당 인스턴스의 정보를 지운다

- DELETE

Eureka Server 에서 특정 client 의 instance 를 제거할때 사용한다

heartbeat 보내는데 문제가 생겼거나 다수의 인스턴스를 실행하다 service discovery 가 이를 제거하지 못하는 경우 사용 될 수 있다

DELETE /eureka/apps/appID/instanceID

DELETE /eureka/apps/test-service/5a7af17d-8800-4408-9855-ac55246d070d 

cs

Spring Boot 와 JWT 로 로그인하기

vel1024 — Tue, 6 Jul 2021 14:15:12 +0900

저번 포스팅(https://sdy-study.tistory.com/269) 에서 이메일로 회원가입을 보내는 방법을 알아봤다

이번에는 JWT 로 로그인을 하는 방법에 대해 알아본다

* 로그인을 위한 사전지식들

1) 인증

: 웹에서 인증을 하기 위해선 과거엔 쿠키, 세션을 사용했지만 현재는 토큰을 이용한 방식을 가장 많이 사용한다

토큰 기반의 인증의 가장 대표적인게 바로 JWT (JSON Web Token) 이다

(참조 : https://sdy-study.tistory.com/44)

2) JWT

: JWT (Json Web Token) 은 JSON 포맷을 이용하여, 유저에 대한 속성을 저장하는 Claim 기반의 Web Token 이다

JWT 는 토큰 자체를 정보로 사용하는 Self-Contained 방식으로 정보를 저장한다

(JWT 에 대한 자세한 구조는 링크 참조 : https://mangkyu.tistory.com/56)

3) JWT 를 통한 로그인 과정

: JWT 를 통한 로그인 과정을 요약하면 아래와 같다 (세부적인 내용은 구현하는 사람에 따라 약간 다를 수 있다)

출처 : https://sanghaklee.tistory.com/47

1. 먼저 클라이언트가 서버로 로그인 요청을 보낸다

2. JWT 를 클라이언트가 가지고 있지 않으면 서버에서 생성한다.

-> 이 포스팅에선 공개키, 개인키를 기반으로 토큰을 생성할 것이다

-> 만약 토큰이 이미 있는 상태로 요청했다면, 서버에선 토큰 검증 절차를 치르고 그에따른 응답을 보낸다

3. (토큰을 생성한 경우) 클라이언트로 넘긴다

4. 다음 요청시에 HTTP Header 에 토큰을 첨부하여 요청한다

(Authorization: Bearer token-value)

5. 토큰 검증하고 그에 따른 응답을 한다

4) Spring Security 가 제공하는 로그인 관련 기본 클래스 및 인터페이스들

a) UsernamePasswordAuthenticationToken 클래스

: username 과 password 를 담고 있는 클래스로, 유저가 로그인시에 입력한 내용들을 담고 있다

b) AuthenticationManager 인터페이스

: authenticate 라는 메소드를 가지고 있으며, 이 메소드의 매개변수는 Authentication 이라는 인터페이스가 들어가고, 자체적인 인증 로직을 거치는 기능을 갖고 있다.

c) AuthenticationManagerBuilder 클래스

: AuthenticationManager 인터페이스를 생성하는 빌더이며, 인증 방식에 대한 설정을 지정한다

(DB 방식인지, In-memory 방식인지 등)

d) UserDetailsService 인터페이스

: 유저가 입력한 로그인 데이터를 다루는 인터페이스이며 이 인터페이스는 직접 구현을 해줘야한다

구현 방법은 해당 프로젝트가 어떤 방식의 인증을 쓰느냐에 따라 달라진다

Redis 와 같은 in-memory 를 이용해서 인증을 하는지

아니면 DB 를 이용해서 인증을 하는지

혹은 LDAP 를 이용해서 인증을 하는지 등등에 따라 달라질 수 있다.

(여기서는 유저 정보를 DB에 담아서 사용하므로 DB 인증 방식을 사용했다)

e) UserDetails 인터페이스

: DB 로 부터 가져온 유저 정보를 담는 인터페이스이다.

5) 4) 에서 언급한 기본 클래스 및 인터페이스를 이용하여 로그인을 하는 과정 요약

- 먼저 4)에서 언급한 AuthenticationManager 를 Spring Bean 으로 등록해야 한다 (인증 처리를 위함임)

- AuthenticationManagerBuilder 를 이용해서 위에서 언급한 인증 방식을 설정한다 (여기선 DB 방식으로)

- 설정을 모두 마친뒤, Controller 가 유저가 입력한 로그인정보를 받게 하고 Service 로 넘긴다

- Service 클래스에서 UsernamePasswordAuthenticationToken 인스턴스를 생성하여 유저의 입력정보를 담는다

- 그리고 이 인스턴스를 AuthenticationManager 가 인증처리하도록 authenticate() 메소드를 호출한다

AuthenticationManager 가 처리를할때, UserDetailsService 를 구현한 자체 클래스에서 정의한 방식대로 (DB 방식인지, in-memory 방식인지) 에 맞춰서 처리한다.

(DB 방식으로 구현했으므로, 유저 정보를 가져와서 인증 절차를 실시하고 이에 대한 결과물은 UserDetails 와 Authentication 에 담긴다, 그리고 이들은 다시 AuthService 로 전달된다)

- SecurityContextHolder 에 이 인증 내용을 담는다

- JWT 를 생성하고 유저에게 넘겨준다.

* Spring Boot 와 JWT 를 통한 로그인 코드들

: 위 내용을 Spring Boot 에서 코드로 구현하면 다음과 같다

0) SecurityConfig

: 이전 포스팅(https://sdy-study.tistory.com/269) 에서 아래 내용을 추가

@EnableWebSecurity
@AllArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    private final UserDetailsService userDetailsService;
 
    @Bean(BeanIds.AUTHENTICATION_MANAGER)
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder.userDetailsService(userDetailsService)
                .passwordEncoder(passwordEncoder());
    }
}
Colored by Color Scripter

cs

 

1) Controller

@RestController
@RequestMapping("/api/auth")
@AllArgsConstructor
public class AuthController {
 
    private final AuthService authService;
 
    @PostMapping("/login")
    public AuthenticationResponse login(@RequestBody LoginRequest loginRequest) {
        return authService.login(loginRequest);
    }
}
Colored by Color Scripter

cs

LoginRequest 는 유저가 입력한 로그인 값을 담는 DTO 이다.

2) Service

@Service
@Slf4j
@AllArgsConstructor
public class AuthService {
 
    private final AuthenticationManager authenticationManager;
    private final JWTProvider jwtProvider;
    
    public AuthenticationResponse login(LoginRequest loginRequest) {
        Authentication authenticate = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(loginRequest.getUsername(),
                loginRequest.getPassword()));
        SecurityContextHolder.getContext().setAuthentication(authenticate);
        String authenticationToken = jwtProvider.generateToken(authenticate);
        return new AuthenticationResponse(authenticationToken, loginRequest.getUsername());
    }
}
Colored by Color Scripter

cs

3) JWT 생성

* JWT 생성을 위한 비대칭 암호화 방식(RSA)

: 자바에서 제공하는 KeyStore 를 기반으로 RSA 방식으로 JWT 에 서명을하여 인증을 할 수 있다.

(RSA 에 대한 자세한 설명은 링크 참조 : https://mkil.tistory.com/461)

먼저 jks 파일을 만들어줘야 하는데 다음과 같은 명령어를 커맨드 창에 작성한다

keytool -genkey -alias [alias-이름] -keyalg [사용할 알고리즘, RSA 사용] -keystore [keystore 파일이름 test.jks 이런식] -keysize [keystore 크기, 여기선 2048 사용]

cs

입력하고 나면 비밀번호와 여러가지 내용들을 적을 것을 요청한다

임의로 작성가능 하되 비밀번호는 반드시 기억하고 있어야한다

비밀번호는 application.properties 같은 암호 정보를 담는 파일에 넣는게 좋다

간혹 경고문으로 PKCS12 로 바꾸라고 뜨기도 하는데 그냥 생략해도 된다.

만든 jks 파일은 spring boot 의 resources 폴더 안에 넣어야 한다.

이를 토대로 JWT 를 생성하는 자바 코드를 아래 처럼 작성한다

@Service
public class JwtProvider {
 
    private KeyStore keyStore;
 
    @PostConstruct
    public void init() {
        try {
            keyStore = KeyStore.getInstance("JKS");
            InputStream resourceAsStream = getClass().getResourceAsStream("/jks 파일 이름.jks");
            keyStore.load(resourceAsStream, "jks 생성시 지정한 비밀번호".toCharArray());
        } catch (KeyStoreException | CertificateException | NoSuchAlgorithmException | IOException e) {
            throw new SpringRedditException("keystore 로딩 중 에러 발생");
        }
 
    }
 
    public String generateToken(Authentication authentication) {
        org.springframework.security.core.userdetails.User principal = (User) authentication.getPrincipal();
        return Jwts.builder()
                .setSubject(principal.getUsername())
                .signWith(getPrivateKey())
                .compact();
    }
 
    private PrivateKey getPrivateKey() {
        try {
            return (PrivateKey) keyStore.getKey("jks 파일 생성시 만든 alias", "jks 생성시 지정한 비밀번호".toCharArray());
        } catch (KeyStoreException | NoSuchAlgorithmException | UnrecoverableKeyException e) {
            throw new SpringRedditException("Exception occured while retrieving public key from keystore");
        }
    }
}
Colored by Color Scripter

cs

여기까지 하면 아래 처럼 "JWT 생성" 까지만 끝난 것이다.

아직 JWT 에 대한 검증 작업이 전혀 이뤄지지 않았다

이는 다음 포스팅에서 로그아웃과 함께 다룬다.

Spring Boot 로 이메일 회원가입 하기

vel1024 — Tue, 6 Jul 2021 00:55:59 +0900

토이 프로젝트를 하다가 회원가입과 로그인, 로그아웃 기능을 만들게 되었는데

그때 사용했던 개념들을 정리하고자 한다

먼저 이메일을 통해서 회원가입을 했던 과정을 정리한다

- 개발환경

spring boot : 2.5.2

java : 16

maven : 3.6.3

- 의존성

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
Colored by Color Scripter

cs

thymeleaf 는 이메일 보낼때 적을 내용을 담고 있다

(java 에서 로직처리한 데이터를 전달받아 랜더링하기 위해서 사용됨)

- Gmail 설정하기

: 실제 서비스 운영시에는 Gmail 이 아닌 다른 메일 서버를 사용하겠지만 (보내는 양에 한도가 있기 때문)

여기선 Gmail 을 썼다

그래서 https://www.siteground.com/kb/gmail-smtp-server/ 에 적힌 내용을 기반으로 application.properties 를 다음과 같이 작성했다

application.properties

spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=<개인-gmail-id>
spring.mail.password=<개인-gmail-password>
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

cs

* Spring Boot 에서 Mail 을 보내기 위한 사전지식

: Spring Boot 를 통해서 이메일을 보내기 위해 Spring 에서 제공하는 인터페이스와 클래스들에 대해서 어느정도 사전지식이 필요하다

기본적으로 제공되는 인터페이스 및 클래스들은 다음과 같다

1) MailSender 인터페이스

: 단순한 이메일을 보내기위한 기본 기능들을 제공하는 최상위 레벨의 인터페이스다

2) JavaMailSender 인터페이스

: MailSender 인터페이스의 하위 인터페이스 이며, 이 인터페이스는 MIME 메시지를 지원하고 대체로 MimeMessageHelper 클래스와 같이 쓰인다 (아래 서술할 MimeMessagePreparator 와 같이 쓰임)

3) JavaMailSenderImpl 클래스

: 이름에서 알 수 있듯이 JavaMailSender 인터페이스의 구현 클래스이다.

4) SimpleMailMessage 클래스

: 단순한 메일 보내는데 쓰인다 (단순 텍스트만 보낼때 사용)

5) MimeMessagePreparator 인터페이스

: MIME 메시지 준비를 위해서 필요한 콜백 인터페이스를 제공한다

6) MimeMessageHelper 클래스

: MIME 메시지 생성을 위해 쓰이는 클래스다

이미지, 파일, 텍스트 등을 html 형식으로 제공한다

* MIME 이란 단순 텍스트 뿐 아니라 다른 여러 바이너리 파일을 메일에 첨부할때 쓰인다.

* 이메일로 회원가입하는 코드들

0) SecurityConfig

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    public void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/auth/**")
                .permitAll()
                .anyRequest()
                .authenticated();
    }
 
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}
Colored by Color Scripter

cs

1) Controller

@RestController
@RequestMapping("/api/auth")
@AllArgsConstructor
public class AuthController {
 
    private final AuthService authService;
 
    @PostMapping("/signup")
    public ResponseEntity<String> signup(@RequestBody RegisterRequest registerRequest) {
        authService.signup(registerRequest);
        return new ResponseEntity<>("회원가입 완료", HttpStatus.OK);
    }
 
    @GetMapping("accountVerification/{token}")
    public ResponseEntity<String> verifyAccount(@PathVariable String token) {
        authService.verifyAccount(token);
        return new ResponseEntity<>("계정 활성화가 성공적으로 되었습니다.", HttpStatus.OK);
    }
}
Colored by Color Scripter

cs

RegisterRequest 는 유저로 부터 이메일과 비밀번호를 받는 DTO 이다

이메일을 받은 유저가 링크를 받았을때 그 링크를 클릭하면 그 때 활성화된 계정으로 바뀌도록

verifyAccount 라는 메소드를 추가했다.

2) Service

2-1. AuthService.java

@Service
@Slf4j
@AllArgsConstructor
public class AuthService {
 
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final VerificationTokenRepository verificationTokenRepository;
    private final MailContentBuilder mailContentBuilder;
    private final MailService mailService;
 
    @Transactional
    public void signup(RegisterRequest registerRequest) {
        User user = new User();
        user.setEmail(registerRequest.getEmail());
        user.setPassword(encodePassword(registerRequest.getPassword()));
        user.setEnabled(false);
 
        userRepository.save(user);
 
        String token = generateVerificationToken(user);
        String link = Constants.ACTIVATION_EMAIL + "/" + token;
        String message = mailContentBuilder.build(link);
 
        mailService.sendMail(new NotificationEmail("계정 활성화를 실행해주세요.", user.getEmail(), message));
    }
 
    private String generateVerificationToken(User user) {
        String token = UUID.randomUUID().toString();
        VerificationToken verificationToken = new VerificationToken();
        verificationToken.setToken(token);
        verificationToken.setUser(user);
        verificationTokenRepository.save(verificationToken);
        return token;
    }
 
    private String encodePassword(String password) {
        return passwordEncoder.encode(password);
    }
 
    public void verifyAccount(String token) {
        Optional<VerificationToken> verificationTokenOptional = verificationTokenRepository.findByToken(token);
        verificationTokenOptional.orElseThrow(() -> new CustomException("잘못된 토큰"));
        fetchUserAndEnable(verificationTokenOptional.get());
    }
 
    @Transactional
    public void fetchUserAndEnable(VerificationToken verificationToken) {
        String email = verificationToken.getUser().getEmail();
        User user = userRepository.findByEmail(email).orElseThrow(() -> new CustomException("유저를 찾을 수 없음 " + email));
        user.setEnabled(true);
        userRepository.save(user);
    }
}
Colored by Color Scripter

cs

회원가입시에 이메일 받은 유저가 이메일 링크를 클릭해야만 계정 활성화를 하도록 했다.

그래서 signup 메소드에서 먼저 userRepository.save(user) 로 유저를 DB 에 저장한 이후

이메일에 verificationToken 이라는 검증 토큰을 생성한후 이메일로 보내게 했다.

이메일에서 받은 검증 토큰은 UUID 를 통해서 랜덤값을 만들었다.

검증은 verifyAccout 메소드에서 한다.

그리고 최종적으로 계정활성화는 fetchUserAndEnable 메소드에서 실행한다.

2-2. MailService.java

@Service
@Slf4j
@AllArgsConstructor
public class MailService {
 
    private final JavaMailSender mailSender;
 
    @Async
    void sendMail(NotificationEmail notificationEmail) {
        MimeMessagePreparator messagePreparator = mimeMessage -> {
            MimeMessageHelper messageHelper = new MimeMessageHelper(mimeMessage, true, "UTF-8");
            messageHelper.setFrom("보내는 사람 이메일 ");
            messageHelper.setTo(notificationEmail.getRecipient());
            messageHelper.setSubject(notificationEmail.getSubject());
            messageHelper.setText(notificationEmail.getBody(), true);
        };
 
        try {
            mailSender.send(messagePreparator);
            log.info("활성화 메일이 보내졌다");
        } catch (MailException e) {
            log.error(String.valueOf(e));
            throw new CustomException("메일을 여기로 보내는 중 에러 발생 :  " + notificationEmail.getRecipient());
        }
    }
}
 
Colored by Color Scripter

cs

위에서 언급한 JavaMailSender 와 MimeMessagePreparator, MimeMessageHelper 를 같이 사용하였다.

NotificationEmail 은 이메일 전송시에 담을 제목, 수신자, 이메일 내용 등을 담는 DTO 이다.

3) 메일 내용

AuthService.java 에 보면 회원가입 메소드에 String message = mailContentBuilder.build(link) 가 있다

이는 앞서 설정한 Thymeleaf 뷰 템플릿을 통해서 이메일에 작성할 html 코드를 쓰기 위함이다

MailContentBuilder.java

@Service
@AllArgsConstructor
public class MailContentBuilder {
 
    private final TemplateEngine templateEngine;
 
    String build(String message) {
        Context context = new Context();
        context.setVariable("link", message);
        return templateEngine.process("mailTemplate", context);
    }
}
Colored by Color Scripter

cs

뷰 템플릿에 지정할 변수 link 를 정의했다.

그리고 뷰 템플릿의 파일 이름은 mailTemplate.html 이다

mailTemplate.html

<!DOCTYPE html>
<html lang="ko" xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
    <head>
        <title>이메일 인증 링크</title>
    </head>
    <body>
        <span>계정 활성화를 위해서 아래의 인증 링크를 클릭해주세요.</span><br>
        <a th:href="${link}">인증 링크</a>
    </body>
</html>
Colored by Color Scripter

cs

이후 메일을 실제로 보내게 되면 다음과 같이 이메일을 받을 수 있게 된다.

- References

1) Guide to Spring Email : https://www.baeldung.com/spring-email

2) Spring Boot 이메일 전송 : https://victorydntmd.tistory.com/342

Spring Cloud Netflix Eureka

vel1024 — Mon, 5 Jul 2021 23:34:41 +0900

참조한 강의 : https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%81%B4%EB%9D%BC%EC%9A%B0%EB%93%9C-%EB%A7%88%EC%9D%B4%ED%81%AC%EB%A1%9C%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

- Service Discovery 란

: 클라우드 기반의 마이크로서비스를 운용하는 경우(컨테이너 기술 기반), auto-scaling 같은 기능으로 인해서 마이크로서비스 인스턴스의 IP 주소가 동적으로 변하기 때문에 클라이언트 입장에서 어떤 위치의 IP 주소로 요청해야 하는지 알기가 어렵다. 이런 상황에서 API Gateway 를 통해서 찾고자하는 인스턴스를 제대로 찾으려면 매핑시켜주는 대상이 있어야 할 것이다.

이런 기능을 하는 것이 Service Discovery 이며 Client-side Discovery 와 Server-side Discovery 로 나뉜다.

어떻게 위치를 매핑시킬까? (https://www.nginx.com/blog/service-discovery-in-a-microservices-architecture/)

1) Client-side discovery

: 클라이언트로 등록된 마이크로서비스가 Service Registry 를 찾아가서 특정 인스턴스를 찾아가 호출하는 방식이다

마이크로서비스 인스턴스의 위치는 Service Registry 가 관리하며, 각 인스턴스가 생성될때 등록된다. 인스턴스 삭제시 service registry 에 들어간 값도 삭제됨

출처 : https://www.nginx.com/blog/service-discovery-in-a-microservices-architecture/

Netflix OSS 에서 사용하는 방식이며, Netflix Eureka 가 Service Registry 를 담당한다.

여기에 Netflix Ribbon 이 로드밸런서의 역할을 담당한다

아래에 서술할 코드도 Spring Cloud Netflix Eureka 를 기반으로 한다.

2) Server-side discovery

: 요청이 들어왔을때, 로드배런서를 통해서 service registry 로 질의한뒤, 그에 맞는 인스턴스로 찾아가는 방식이다.

여기서도 마찬가지로 각 마이크로서비스 인스턴스는 service registry 에 등록되어 관리된다.

출처 : https://www.nginx.com/blog/service-discovery-in-a-microservices-architecture/

AWS Elastic Load Balancer (ELB) 가 server-side discovery router 에 해당하는 대표적인 예이며

ELB 는 인터넷으로 들어오는 외부 트래픽을 로드밸런싱 할때 쓰인다.

- Spring Cloud Netflix Eureka 를 통한 마이크로서비스 환경 구현해보기

: 직접 코드를 써보고 간단한 마이크로서비스 환경을 만들어보자

1) Eureka Server

: Spring Intializer 로 spring boot 서버를 만들고 의존성에 spring-cloud-starter-netflix-eureka-server 를 추가하자

-pom.xml

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
Colored by Color Scripter

cs

메인 부분에 @EnableEurekaServer 를 추가하자

-~Application.java

@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServiceApplication.class, args);
    }
}
Colored by Color Scripter

cs

application.yml 에 다음의 내용을 추가하자

-application.yml

server:
  port: 8761
 
spring:
  application:
    name: discovery-service
 
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

cs

spring.application.name : 인스턴스 구분을 위한 이름

eureka.client.register-with-eureka, fetch-registry : eureka client 일때만 true 로 설정한다

2) Eureka Client

: 마찬가지로 spring initializer 로 spring boot 서버를 만들고 다음의 의존성을 추가한다

-pom.xml

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Colored by Color Scripter

cs

- ~Application.java

: @EnableDiscoveryClient 를 추가한다

@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}
Colored by Color Scripter

cs

- application.yml

server:
  port: 9001
 
spring:
  application:
    name: user-service
 
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:8761/eureka

cs

: 위와 거의 똑같은데 Eureka 서버 위치만 service-url.defaultZone 으로 추가해주면 된다.

- 실행 결과

Eureka 서버 하나와 Client 두개를 만들었다

Client 는 9001, 9002 번 포트로 열었고

Instances currently registered with Eureka 에 보면 Status 에 2대가 올라가 있음을 볼 수 있다

(UP 이면 실행 중이라는 의미, DOWN 이면 꺼져있다는 의미)

* 참고로 포트 번호를 위에 처럼 직접 지정해주지 않고 0 으로 지정하면 랜덤한 포트번호가 부여된다.

-> 이때 다수의 인스턴스를 운용시에 유레카서버에서 하나의 인스턴스만 감지하게 된다는 문제가 생긴다

이를 해결하기 위해 application.yml 에

eureka.instance.instance-id: ${spring.cloud.client.hostname}:${spring.application.instance_id:${random.value}}

를 추가하면 된다.

다음은 API Gateway 와 Netflix Zuul 에 대해 알아본다.

Spring Cloud 와 Microservice 란

vel1024 — Thu, 1 Jul 2021 12:31:33 +0900

참조 강의 : https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%81%B4%EB%9D%BC%EC%9A%B0%EB%93%9C-%EB%A7%88%EC%9D%B4%ED%81%AC%EB%A1%9C%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

- IT System 의 역사

출처 : https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%81%B4%EB%9D%BC%EC%9A%B0%EB%93%9C-%EB%A7%88%EC%9D%B4%ED%81%AC%EB%A1%9C%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

- Anti-Fragile 의 주요요소

1) Auto-Scaling

: 사용량에 따라 자동으로 scale-out 하는 방식

2) Microservice

: Monolith 방식 처럼 하나의 큰 프로젝트에 여러 요소 (Frontend, Backend, DB 등) 를 다 넣어서 관리하는게 아니라

각 서비스 마다 개별적인 모듈로 분리해서 관리하는 방식

3) Chaos Engineering

: 예상치 못한 상황에 대응하는 것

4) CI/CD

: 지속적인 통합과 배포

- Cloud Native Architecture 의 특징

1) 확장 가능한 Architecture

: 시스템의 유연한 수평적 확장(Scale-out), 시스템 부하 분산(Load Balancing), Container 기반의 모듈 관리 등

2) 탄력적인 Architecture

: 서비스의 생성, 통합, 배포에 있어서 비지니스 요구사항 변화에 따라 유연하게 대처

3) Fault Isolation

: Microservice 를 기반으로 하므로, 특정 서비스에 장애 발생시 다른 서비스에 큰 영향을 주지 않을 수 있음

- Cloud Native Application 의 주요 요소

1) CI/CD

2) DevOps

3) Microservice

4) Container

- 12 Factors

: Cloud Native Application 을 구축함에 있어서 고려해볼만한 12가지 사항

참조 : https://12factor.net/ko/

The Twelve-Factor App (한국어)

배경 이 문서에 기여한 사람들은 수백개 앱의 개발과 배포에 직접 참여했으며, Heroku 플랫폼을 통해서 방대한 앱의 개발, 운영, 확장을 간접적으로 관찰했다. 이 문서는 실제로 쓰이는 다양한 SaaS

12factor.net

- Monolithic architecture 와 Microservice architecture

출처 : https://www.geeksforgeeks.org/monolithic-vs-microservices-architecture/

그림에서 알 수 있듯이

Monolithic architecture 는 하나의 큰 프로젝트 안에서 여러 서비스들을 통합적으로 넣어놓은 것 이라면

Microservice architecture 는 서비스들 마다 개별 모듈로 분리해서 관리하는 방식

예를들어, 쇼핑몰 사이트를 운영한다고 하면,

유저 정보를 관리하는 User microservice

주문 정보를 관리하는 Order microservice

상품 정보를 관리하는 Product microservice 등 으로 나눠서 생각해볼 수 있고

이런 식으로 분할해서 전체 서비스를 관리하는 것을 microservice architecture 라 한다

- microservice 의 특징과 이점

참조 : https://aws.amazon.com/ko/microservices/

마이크로서비스란 무엇입니까? | AWS

마이크로서비스의 경우 각 서비스가 지원하는 애플리케이션 기능의 수요를 충족하도록 해당 서비스를 독립적으로 확장할 수 있습니다. 따라서 팀은 필요한 인프라의 규모를 적절히 조절하고,

aws.amazon.com

- 표준 MSA 구성요소

출처 : https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%81%B4%EB%9D%BC%EC%9A%B0%EB%93%9C-%EB%A7%88%EC%9D%B4%ED%81%AC%EB%A1%9C%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

- MSA 에 사용되는 주요 기술들

출처 : https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%81%B4%EB%9D%BC%EC%9A%B0%EB%93%9C-%EB%A7%88%EC%9D%B4%ED%81%AC%EB%A1%9C%EC%84%9C%EB%B9%84%EC%8A%A4/dashboard

- 무조건 microservice 를 도입해야 하는가

다음의 질문 사항들을 생각해보고, 만들고자 하는 서비스가 얼마나 부합한지에 따라서 결정하는게 좋다

1) 변화의 빈도수가 높은가

2) 각 서비스가 독립적인 확장성을 가져야하는가

3) 각 서비스가 독립적인 라이프 사이클을 가지는가

4) 서비스간의 경계가 구분이되는가 (외부 종속성과 상호작용이 단순한지 등)

5) 하나의 기술 뿐 아니라 다른 여러 기술이 필요한가

6) 격리된 오류가 필요한가

- SOA 와 MSA 의 차이

SOA 는 Service Oriented Architecture 를 의미하고

MSA 는 Microservice Architecture 를 의미한다

둘다 서비스 단위로 개발한다는 특징이 있으나

SOA 는 하나의 서비스가 다른 서비스에서 재사용하게 만드는 특징이 있으나

MSA 는 서비스를 서로 공유하는게 아니라 각각이 독립적으로 실행되는 것을 지향한다는게 차이점이다

또한 SOA 는 ESB, SOAP 등 여러 미들웨어를 통해서 서로 통신하지만

MSA 는 RESTful API 를 통해서 통신한다는게 차이점이다

- Spring Cloud 란

: Microservice 의 개발, 배포, 운영에 관한 아키텍처를 쉽게 구성할 수 있도록 제공하는 Spring Boot 기반의 프레임워크다

출처 : https://happycloud-lee.tistory.com/207

(각 요소들에 대한 자세한 사항은 차후에 포스팅)

Swagger 를 통한 REST API 문서화

vel1024 — Fri, 30 Apr 2021 14:26:34 +0900

백엔드 개발자가 작성한 REST API 를 프론트엔드 개발자에게 문서화해서 넘겨줄때,

매번 일일이 문서화하여 작성하는 일은 매우 불편할 것이다

그래서 이런 단점을 개선하기위해 나온 것이 Swagger 이다

Swagger 는 백엔드 개발서버가 실행될때, 백엔드 서버내의 모든 API 를 탐색해서 알아서 문서화하여 UI 까지 제공한다

사용방법도 어렵지 않다

* 3.0 이상의 버전과 그 이하의 버전은 적용방법이 약간 다르다

여기서는 3.0 미만의 버전만 설명한다

또한 maven을 기준으로 설명되어 있다

(3.0 이상의 버전은 아래 링크 참조)

woowacourse.github.io/javable/post/2020-08-31-spring-swagger/

API 문서 자동화 - Swagger 팔아보겠습니다

Spring REST Docs 같이 테스트 코드 작성하면서 문서화하는게 지겹다고요? 문서 화면을 알록달록 이쁘게 만들고 싶다고요? 간단한 코드로 컬러풀한 문서를 만든다!! Swagger가 있습니다. Swagger…

woowacourse.github.io

- pom.xml

<properties>
    <springfox.version>2.9.2</springfox.version>
</properties>
 
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>${springfox.version}</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>${springfox.version}</version>
</dependency>
Colored by Color Scripter

cs

의존성 설치 이후에 아래와 같이 자바 설정 파일을 만들어준다.

- SwaggerConfiguration.java

@Configuration
@EnableSwagger2
public class SwaggerConfiguration {
 
    @Bean
    public Docket Api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build()
                .apiInfo(getApiInfo());
    }
 
    private ApiInfo getApiInfo() {
        return new ApiInfoBuilder()
                .title("<Site Name> API")
                .version("<Site Version>")
                .description("API for <Site Name> Application")
                .contact(new Contact("<API Provider Name>", "<API Provider contact url>", "<API Provider email>"))
                .license("<License Name>")
                .build();
    }
}
Colored by Color Scripter

cs

1. Docket 은 Swagger 를 설정할수 있게 도와주는 클래스이다.

- select() : ApiSelectorBuilder 를 생성해서 apis() 와 paths() 를 사용할 수 있게 한다

- apis() : api 가 작성되어 있는 패키지를 지정한다

- paths() : apis() 로 선택된 API 중 원하는 path 를 지정하고 문서화하는 역할을 한다

* apis() 와 paths() 내부에 전부 any() 로 쓴 것은 백엔드 서버 내에 API 가 많지 않다고 가정했기 때문이다

특정 api 의 카테고리만 하고 싶다면 PathSelectors.ant("/users/**") 이런식으로 할 수도 있다.

2. ApiInfo 는 그냥 이름에서도 알 수 있듯, API 정보를 지정하는 부분인데, 이 클래스에 대한 생성자 매개변수는 아래와 같다.

(위에선 builder pattern 으로 작성됨)

public ApiInfo(
    String title,
    String description,
    String version,
    String termsOfServiceUrl,
    Contact contact,
    String license,
    String licenseUrl,
    Collection<VendorExtension> vendorExtensions)

cs

각각에 대한 내용은 아래 처럼 swagger ui 에 나타나게 된다.

출처 : https://woowacourse.github.io/javable/post/2020-08-31-spring-swagger/

- References)

1. woowacourse.github.io/javable/post/2020-08-31-spring-swagger/

2. swagger.io/docs/

MapStruct 란?

vel1024 — Thu, 15 Apr 2021 20:59:09 +0900

Mapstruct 란 클래스간 변환을 쉽게 하기 위해 등장한 라이브러리다

- DTO, Entity

: DTO 란 Data Transfer Object 를 말하며, 계층간 데이터 전송을 위해 만든 Bean 을 의미한다

Entity 란 DB 의 테이블과 매핑시키기 위한 자바 객체를 의미한다

Entity 에 정의해둔 필드변수 외에도 별도로 어떤 값을 유저로 부터 받아와야 한다거나 혹은 Entity 에는 없는 필드를 리턴시켜줘야 할때, DTO 를 이용하는데, 이런 작업을 가능하게하려면, Entity 와 DTO 간에 매핑과정이 필요하다

- maven 을 이용하는 경우

: maven 을 이용하는 경우 의존성 주입을 다음과 같이 해줘야 한다

pom.xml

    <dependencies>
 
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
 
        <!-- mapstruct -->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${org.mapstruct.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok-mapstruct-binding</artifactId>
            <version>0.2.0</version>
        </dependency>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>0.2.0</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>
Colored by Color Scripter

cs

위와 같이 lombok 과 같이 쓰는 경우 mapstruct 라이브러리와 같이 연동하려면, <build> 부분에 lombok-mapstruct-binding 을 넣어줘야 한다.

- 예제

: 예를들어, 어떤 커뮤니티 사이트를 만든다고 가정하고, 작성할 글의 카테고리 관련한 API 를 만든다고 했을때, Entity 와 DTO 를 다음과 같이 구성했다고 하자

- Entity

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
public class Category {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @NotBlank(message = "Category name is required !")
    private String name;
 
    @NotBlank(message = "Description is required !")
    private String description;
 
    @OneToMany(fetch = FetchType.LAZY)
    private List<Post> posts;
 
    private Instant createdDate;
 
    @ManyToOne(fetch = FetchType.LAZY)
    private User user;
}
 
Colored by Color Scripter

cs

- DTO

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CategoryDto {
    private Long id;
    private String name;
    private String description;
    private Integer postCount;
}

cs

Entity 클래스엔, 필드 변수가 id, name, description, posts, createdDate, user 가 있지만,

DTO 클래스에는, id, name, description, postCount 로 구성되어 있다

두 클래스의 필드 변수가 서로 일치하지 않으므로, mapper 인터페이스를 선언해야 한다

- mapper interface

@Mapper(componentModel = "spring")
public interface CategoryMapper {
 
    @Mapping(target = "postCount", expression = "java(mapPosts(category.getPosts()))")
    CategoryDto mapCategoryToDto(Category category);
 
    default Integer mapPosts(List<Post> postCount) {
        return postCount.size();
    }
 
    @InheritInverseConfiguration
    @Mapping(target = "posts", ignore = true)
    @Mapping(target = "createdDate", expression = "java(java.time.Instant.now())")
    Category mapDtoToCategory(CategoryDto categoryDto);
}
Colored by Color Scripter

cs

첫번째 메소드인 mapCategoryToDto 는 엔티티 클래스를 입력 받아서 DTO 로 변환시키는 작업을 하고

두번째 메소드는 그 반대로 DTO 를 엔티티로 변환시키는 역할을 맡고 있다

각 필드를 매핑시킬때는, @Mapping 어노테이션을 쓰고, target 은 매핑될 타겟 클래스의 타겟 필드 변수이름을 말하고

expression 은 어떤 값으로 넣을지에 대한 자바 구문을 넣는 속성값을 의미한다

그리고 여기엔 나와있지 않지만, source 라는 것도 있으며, target 과 매핑될 소스 객체의 소스 필드 변수이름을 의미한다

- References)

1. DTO, VO, DAO : genesis8.tistory.com/214

2. mapstruct : mapstruct.org/