• p.51 확인 문제 3번

  프로그램이 실행되려면 반드시 [ ]에 저장되어 있어야 합니다.

프로그램이 실행되려면 메모리에 저장되어 있어야합니다.

• p.65 확인 문제 3번

  $1101_{(2)}$의 음수를 2의 보수 표현법으로 구해 보세요.

  1101 -> 0과 1 뒤집기 0010 -> 1 더하기 $1101_{(2)}$의 음수는 $0011_{(2)}$ 입니다.

  ✨ 추가숙제

  • p.100 스택과 큐의 개념을 정리하기

  스택(Stack)

  후입선출(LIFO : Last-In First-Out)

  • 가장 최근에 들어온 데이터가 가장 먼저 나감

• 스택의 용도

  • 되돌리기
  • 함수호출
  • 괄호검사
  • 계산기 : 후위표기식 계산, 중위 표기식의 후위 표기식 변환
  • 미로탐색

큐(Queue)

선입선출(FIFO : First-In First-Out)

• 가장 먼저 들어온 데이터가 가장 먼저 나감
• 큐의 용도
  • 컴퓨터의 작업 큐 : 버퍼링
  • 시뮬레이션의 대기열
  • 통신에서의 데이터 패킷들의 모델링에 이용

git bash: git remote 프로젝트에 재연결시키기로는 해결이 되지 않아 github 계정을 연동하는 방법을 다르게 했다. 일반적인 웹에서 로그인하여 연결시키는 것이 아닌 SSH 방식으로 연결.

먼저 gitbash에서 ssh를 발급받기 위한 키를 생성받는다. $ ssh-keygen -t ed25519 -C "your_email@example.com"

그 후 콘솔에서 경로 설정, 비밀번호 설정을 거친 뒤 (✨비밀번호는 입력되는 게 보이지 않아야 정상) ssh키를 발급받은 경로에 가서 이 아이들이 예쁘게 있는지 확인하고

.pub 확장자 파일을 메모장 등으로 열어준다. 내부에 보이는 코드를 복사 한 뒤 github > 내 프로필 사진 클릭 > Settings > SSH and GPG keys > New SSH key

key에 붙여넣기를 한 후 Add SSH key를 누르고 이런 key가 생성이 되었다면 성공.

생성이 되었다면 앞으로 git 원격 연결을 할 때,

이렇게 있어보이는 ssh 탭에서 멋있는 URL을 기존 연결 방식 처럼 사용하면 되겠다.

🫠

docker 실행시 cmd에 mysql 생성 안 되는 에러 해결

• mysql-data 파일 권한 설정.

  • sudo chown -R 1000:1000 ./db/mysql/data
  • 권한 설정은 정상적으로 들어갔지만 여전히 파일을 찾지 못하거나 권한을 부여받지 못함. = 실패 😭

• 📌 명시적 접근 설정.

• docker-compose.yml 파일 마지막 줄에 추가

-> volume:  
mysql-data:

• 제대로 파일을 찾고 권한을 부여 받았지만 타 팀원분들은 이 볼륨 세션을 등록할 경우 접근권한 없음 에러 발생. = 규성님만 성공 🙄 = 결과적으로 실패😭

• 📌 파일 중복 문제.

• 서로 다른 두개의 파일이 존재하기에 하위 폴더를 삭제 후 docker 재실행 = 실패 😭

• 💡 프로젝트 제거 후 다시 받아오기

• • 프로젝트 파일의 모든 내용을 제거하고 새로 프로젝트 파일을 생성하여 다시 clone.

    • 파일이 삭제된 후 다시 다운로드 된 경로를 살펴보니 오류가 존재하던 때의 파일 경로와 다른 것을 발견.
      정확한 파일 경로로 리빌드 되면서 오류 해결.
      = 성공 😁

application.yml OAuth 오류 해결 과정

• 해당 사진의 오류로 애플리케이션 구성의 문제임을 확인함.

• 카카오 provider Id를 찾을 수 없음을 확인

• code With Me를 통해 문제점 파악

• 오래 걸렸지만 원인은 들여쓰기 문제였음😭

🐱‍🏍--- ---🤸🏻‍♀️ ~ 야호~

• 🆕 AOP 추가하기
  • 모든 API(Controller)가 호출될 때, Request 정보(Request URL, HTTP Method)를 @Slf4J Logback 라이브러리를 활용하여 Log로 출력해주세요.
  • 컨트롤러 마다 로그를 출력하는 코드를 추가하는것이 아닌, AOP로 구현해야만 합니다.

    @Pointcut("execution(* com.prac.music.domain.board.controller.*.*(..))")
    private void board() {}
    

@Pointcut("execution(* com.prac.music.domain.comment.controller..(..))") private void comment() {}

@Pointcut("execution(* com.prac.music.domain.like.controller..(..))") private void like() {}

@Pointcut("execution(* com.prac.music.domain.mail.controller..(..))") private void mail() {}

@Pointcut("execution(* com.prac.music.domain.user.controller..(..))") private void user() {}

@Around("board() || comment() || like() || mail() || user()" ) public Object execute(ProceedingJoinPoint joinPoint) throws Throwable { log.info(joinPoint.getSignature().toShortString() + " start");

    try {

        return joinPoint.proceed();

    } finally {

        log.info(joinPoint.getSignature().toShortString() + " end");

    }
}

![](https://velog.velcdn.com/images/2_minus/post/5d5741fc-ef56-465c-bdf3-c0d4984289d5/image.png)

- api가 실행될때, 끝날때 api의 이름을 출력하는 log 
  - domain 방식으로 설계된 프로젝트여서 각각의 controller를 지정하는 @Pointcut이 많은 것이 아닌가라는 생각이 든다.




- [X]  **🆕 DTO, Entity Test 추가하기**
    - `@Test` 를 사용해서 DTO 와 Entity Test 를 추가합니다.
    - User, Post, Comment, DTO 에 존재하는 메서드들에 대해서 “**단위 테스트”** 를 추가합니다.
    - 특정 상황에 예외가 정상적으로 발생하고 있는지도 테스트 합니다.
```java
@Test
    @DisplayName("User Entity Test")
    void test1() throws IOException {
        // given
        SignupRequestDto requestDto = new SignupRequestDto(
                "testId1",
                "testPassword1!",
                "testName",
                "test@email.com",
                "test Introduce"
        );

        MultipartFile file = null;

        // when
        User user = userService.createUser(requestDto, file);

        // then
        assertEquals(requestDto.getUserId(), user.getUserId());
        assertTrue(passwordEncoder.matches(requestDto.getPassword(), user.getPassword()));
        assertEquals(requestDto.getName(), user.getName());
        assertEquals(requestDto.getEmail(), user.getEmail());
        assertEquals(requestDto.getIntro(), user.getIntro());
    }

• given 에 입력값, when에 생성 메서드(Post api)를 동작시켜 비교시켜 테스트

  • 게시글과 댓글은 종속된 엔티티가 테스트 코드 내에서 제대로 존재하지 않아서 통과하지 못하는 것으로 보인다.

• 🆕 Controller Test 추가하기
  • @WebMvcTest 를 사용하여 Controller Test 를 추가합니다.
  • Post, Comment Controller 에 대해서 테스트를 추가합니다.
  • 특정 상황에 예외가 정상적으로 발생하고 있는지도 테스트 합니다.

🛠️ 오류해결

• ✨ JpaAuditing 관련 어노테이션 부착 후 해결

@WebMvcTest(
        controllers = UserController.class,
        excludeFilters = {
                @ComponentScan.Filter(
                        type = FilterType.ASSIGNABLE_TYPE,
                        classes = SecurityConfiguration.class
                )
        }
)
@MockBean(JpaMetamodelMappingContext.class)
class UserControllerTest {
    private MockMvc mvc;
    private Principal mockPrincipal;

    @Autowired
    private WebApplicationContext context;

    @Autowired
    private ObjectMapper objectMapper;

    private PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    @MockBean
    private UserService userService;

    private JwtService jwtService = new JwtService();

    @BeforeEach
    public void setup() {
        mvc = MockMvcBuilders.webAppContextSetup(context)
                .apply(springSecurity(new MockSpringSecurityFilter()))
                .build();

    }

    @Test
    @DisplayName("Signup Request")
    void test1() throws Exception {

        //given
        SignupRequestDto requestDto = SignupRequestDto.builder()
                .userId("testId1")
                .password("testPassword1!")
                .name("testName")
                .email("test@email.com")
                .intro("test Introduce")
                .build();

        MockMultipartFile file = new MockMultipartFile(
                "file",
                "profileImage.png",
                "multipart/form-data",
                "some image content".getBytes()
        );

        MockMultipartFile user = new MockMultipartFile(
                "user",
                "",
                "application/json",
                objectMapper.writeValueAsBytes(requestDto)
        );

        // when - then
        mvc.perform(multipart("/api/users/signup")
                        .file(user)
                        .file(file))
                .andExpect(status().isOk())
                .andDo(print());
    }

    @Test
    @DisplayName("Login Request")
    public void test2() throws Exception {

        //given
        LoginRequestDto requestDto = LoginRequestDto.builder()
                .userId("testId1")
                .password("testPassword1!")
                .build();

        String jsonRequest = objectMapper.writeValueAsString(requestDto);

        //when - then
        mvc.perform(post("/api/users/login")
                        .contentType("application/json")
                        .content(jsonRequest))
                .andExpect(status().isOk())
                .andDo(print());
    }

    @Test
    @DisplayName("Logout Request")
    public void test3() throws Exception {

        // given
        User user = User.builder()
                .userId("testId1")
                .build();
        UserDetailsImpl userDetails = new UserDetailsImpl(user);
        mockPrincipal = new UsernamePasswordAuthenticationToken(userDetails, "");

        // when
        userService.logoutUser(userDetails.getUser());

        // then
        mvc.perform(put("/api/users/logout")
                        .principal(mockPrincipal))
                .andExpect(status().isOk())
                .andDo(print());
    }

    @Test
    @DisplayName("Signout Request")
    public void test4() throws Exception {

        // given
        User user = User.builder()
                .id(1L)
                .userId("testId1")
                .password("testPassword1!")
                .name("testName")
                .email("test@email.com")
                .intro("test Introduce")
                .status(UserStatusEnum.NORMAL)
                .refreshToken("fidsbafilubasdjiklfboia")
                .profileImage(null)
                .build();

        SignoutRequestDto requestDto = SignoutRequestDto.builder()
                .password("testPassword1!")
                .build();

        UserDetailsImpl userDetails = new UserDetailsImpl(user);
        mockPrincipal = new UsernamePasswordAuthenticationToken(userDetails, "");
        // when

        // then
        mvc.perform(put("/api/users/signout")
                        .principal(mockPrincipal)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(requestDto)))
                .andExpect(status().isOk())
                .andDo(print());
    }


}

JpaAuditing 관련 오류 외에도 기존 프로젝트에서 SignOut api 가 실행이 안되는 500코드 오류 발생

• 기존 requestDto의 필드가 하나 밖에 없어서 생기는 오류였음

• @Jacksonized 어노테이션으로 해결

• 🆕 Service Test 추가하기
  • @ExtendWith 를 사용하여 Service Test 를 추가합니다.
  • User, UserDetails, Post, Comment Service 에 대해서 “통합 테스트” 를 추가합니다.
  • 단순 DB CRUD 와 별개로 코드 레벨에서의 비즈니스 로직에 대한 테스트가 필요한 경우라면 “단위 테스트”를 추가합니다.
    • ex) 비밀번호가 암호화 되었는가
  • 특정 상황에 예외가 정상적으로 발생하고 있는지도 테스트 합니다.

package com.prac.music.service;

import com.prac.music.domain.board.dto.BoardRequestDto;
import com.prac.music.domain.board.dto.BoardResponseDto;
import com.prac.music.domain.board.service.BoardService;
import com.prac.music.domain.user.entity.User;
import com.prac.music.domain.user.entity.UserStatusEnum;
import com.prac.music.domain.user.service.JwtService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.List;

import static org.hibernate.validator.internal.util.Contracts.assertNotNull;

@ExtendWith(MockitoExtension.class) // @Mock 사용을 위해 설정합니다.
public class BoardServiceTest {

    @Mock
    JwtService jwtService;

    @InjectMocks
    BoardService boardService;

    User user;

    @BeforeEach
    public void setUp() {
        user = User.builder()
                .id(1L)
                .userId("testId1")
                .password("testPassword1!")
                .name("testName")
                .email("test@email.com")
                .intro("test Introduce")
                .status(UserStatusEnum.NORMAL)
                .refreshToken(jwtService.createRefreshToken("testId1"))
                .profileImage(null)
                .build();

    }

    @Test
    @DisplayName("createBoard Success")
    void test1() throws IOException {
        //given
        BoardRequestDto requestDto = BoardRequestDto.builder()
                .title("test title")
                .contents("test contents")
                .build();
        List<MultipartFile> files = List.of();
        //when
        BoardResponseDto createdBoard = boardService.createBoard(requestDto, user, files);

        //then
        assertNotNull(createdBoard);
    }
}

@Setup 어노테이션으로 기존재해야할 엔티티를 미리 작성하고 테스트를 진행하는 방식으로 작성했다. 그런데 작성하고 보니 기존 Entity Test에서 진행했던 방식과 동일한 것으로 여겨져서 Entity Test를 더 단순하게 생각했어야 하는 구나 하고 생각했다.

이제 우리 서버에서 인증코드를 담은 메일을 전송하고, 그것으로 어떻게 사용자를 인증할 것인지에 대해 생각해 봐야한다.

메일 인증 기능 흐름

메일 전송

사용자 : 메일 입력 -> 서버 : 입력된 메일로 코드 전송

메일 검증

사용자 : 전송된 코드를 서버에 입력 -> 서버 : 입력 받은 코드와 발송한 코드가 일치하는 지 검증

고려사항

• 사용자에게 보낸 인증 코드를 검증하기 위해서는 서버에 발송된 코드를 저장 할 필요가 있다.
• 인증 코드는 한 가지만 유효하게 한다. : 재발송시 기존 코드는 무효화

기능 구현

Mail Entity

@Getter
@NoArgsConstructor
@Entity
@Table(name = "mail")
public class Mail extends BaseTimeEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Long id;
    // 인증 여부
    @Column
    private boolean status;
    // 메일 주소
    @Column
    private String email;
    // 인증 코드
    @Column
    private String code;
    // 사용자와 1대1 연결
    @OneToOne
    @JoinColumn(name = "user_id", nullable = false)
    private User user;

    @Builder
    public Mail(User user) {
        this.user = user;
        this.email = user.getEmail();
        this.code = "";
        this.status = false;
    }
    // 인증 코드 업데이트
    public void mailAddCode(String code) {
        this.code = code;
    }

• id: 메일 엔티티의 고유키
• status: 인증 여부 상태를 나타내는 필드
• email: 메일을 발송한 메일 주소
• code: 인증 코드
• User: 인증 대상 사용자

MailController

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users/email")
public class MailController {
    private final MailService mailService;
    // 메일 전송
    @PostMapping("/send")
    public ResponseEntity<String> sendMail(@RequestBody MailRequestDto requestDto) throws MessagingException {
        mailService.sendMail(requestDto);
        return ResponseEntity.ok(requestDto.getEmail() + "로 인증코드가 발송되었습니다.");
    }
    // 메일 검증
    @PostMapping("/verify")
    public ResponseEntity<String> verifyMail(@RequestBody VerifyRequestDto requestDto) {
        mailService.verifyMail(requestDto);
        return ResponseEntity.ok("입력하신 메일 " + requestDto.getEmail() + "이 정상적으로 인증되었습니다.");
    }
}

MailService

sendMail

    public void sendMail(MailRequestDto requestDto) {
        Mail mail = checkAndSaveMail(requestDto.getEmail());
        MimeMessage emailForm = createMailForm(mail);
        javaMailSender.send(emailForm);

    }

MailRequestDto 객체를 매개변수로 받는 sendMail 메서드

// MailRequestDto.java
@Getter
@NoArgsConstructor
public class MailRequestDto {
    private String email;

    @Builder
    public MailRequestDto(String email) {
        this.email = email;
    }
}

requestDto 객체에서 메일 주소를 받아서 checkAndSaveMail 메서드를 수행

private Mail checkAndSaveMail(String email) {
        User user = getUserByEmail(email);
        Optional<Mail> checkMail = mailRepository.findByEmail(user.getEmail());
        checkMail.ifPresent(mailRepository::delete);
        Mail mail = Mail.builder()
                .user(user)
                .build();

        return mailRepository.save(mail);
    }

사용자에게 보낼 메일 형태 생성 후 전송

private MimeMessage createMailForm(Mail mail) {
        String code = createCode();
        mail.mailAddCode(code);

        MimeMessage message = javaMailSender.createMimeMessage();

        try {
            MimeMessageHelper messageHelper = new MimeMessageHelper(message, true);
            String senderEmail = "noreply_88@gmail.com";
            messageHelper.setFrom(senderEmail);
            messageHelper.setTo(mail.getEmail());
            messageHelper.setSubject("[88하게] 이메일 인증 번호 발송");

            String body = "<html><body style='background-color: #000000 !important; margin: 0 auto; max-width: 600px; word-break: break-all; padding-top: 50px; color: #ffffff;'>";
            body += "<h1 style='padding-top: 50px; font-size: 30px;'>이메일 주소 인증</h1>";
            body += "<p style='padding-top: 20px; font-size: 18px; opacity: 0.6; line-height: 30px; font-weight: 400;'>서비스 사용을 위해 회원가입 시 고객님께서 입력하신 이메일 주소의 인증이 필요합니다.<br />";
            body += "하단의 인증 번호로 이메일 인증을 완료하시면, 정상적으로 서비스를 이용하실 수 있습니다.<br />";
            body += "<div class='code-box' style='margin-top: 50px; padding-top: 20px; color: #000000; padding-bottom: 20px; font-size: 25px; text-align: center; background-color: #f4f4f4; border-radius: 10px;'>" + code + "</div>";
            body += "</body></html>";
            messageHelper.setText(body, true);
        } catch (MessagingException e) {
            e.printStackTrace();
        }
        return message;
    }

// 이메일 인증코드 생성
    private String createCode() {
        int numberzero = 48; // 0 아스키 코드
        int alphbetz = 122; // z 아스키 코드
        int codeLength = 8; // 인증코드의 길이
        Random rand = new Random(); // 임의 생성

        return rand.ints(numberzero, alphbetz + 1)
                .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97)) // 숫자와 알파벳만 허용
                .limit(codeLength)
                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
                .toString();
    }

verifyMail

public void verifyMail(VerifyRequestDto requestDto) {
        LocalDateTime now = LocalDateTime.now(); // 유효시간 체크를 위한 현재시간 체크
        User user = getUserByEmail(requestDto.getEmail());

          // 해당하는 메일주소가 없는 경우.
        Mail mail = mailRepository.findByEmail(user.getEmail()).orElseThrow(
                () -> new MailServiceException("잘못된 이메일입니다.")
        );

          // 인증 유효시간 180초가 지난 경우
        LocalDateTime timeLimit = mail.getCreatedAt().plusSeconds(EXPIRED_TIME);
        String targetCode = mail.getCode();
        String code = requestDto.getCode();

        if (now.isAfter(timeLimit)) {
            throw new MailServiceException("만료된 인증코드입니다.");
        }

          // 발송된 코드와 입력받은 코드가 일치하는 경우
        if (targetCode.equals(code)) {
            user.updateStatusVeryfied(); // 사용자의 상태를 임시 -> 정상으로 변경
        }
    }

서로 맡은 바를 잘 이루어 냈고 소통도 원활히 진행하여 서로의 진행사항을 잘 알았다.

Problem

코드 컨벤션이 잘 이루어지지 않아서 기능 역할 분배가 잘 이루어지지 않아서 아쉬웠다. 그리고 깃 이슈, 코멘트를 사용하지 못 해서 아쉬웠다.

Try

코드 컨벤션을 사전에 팀원들과 충분히 이야기한 후에 작업을 진행하는 것이 좋을 것 같다. 깃에 있는 기능들 comment 라던가 lssues 를 더 활용하는 방식으로 진행해면 좋을 것 같다.

Gmail SMTP 설정

G메일에서 우측상단 톱니바퀴를 누르고, [ 모든 설정 보기 ] 버튼을 눌러줍니다. 전달 및 POP/IMAP 탭을 살펴보고 아래 사항을 확인해둡시다.

• SMTP를 이용하려면, IMAP사용이 체크 되어 있어야 합니다. IMAP(Internet Message Access Protocol)은 메일을 읽어오는 클라이언트/서버 프로토콜인데, "발송" 기능과 관련이 있을까 싶긴 했는데, 아무튼 사용으로 체크해둡니다. 그러면, 아래처럼 상태: IMAP를 사용할 수 있습니다.로 표시됩니다.   구글 계정으로 들어갑니다.(SMTP 사용을 위한 인증을 진행해줘야 합니다.)   왼쪽 [보안] 메뉴를 선택하고, 2단계 인증을 진행해줘야 합니다. 저는 휴대폰을 이용해서 2단계 인증을 진행했습니다. 그리고 2단계 인증 메뉴를 선택하고 하위로 들어가보면,   하단에, "앱 비밀번호"라는 게 있습니다. 당장 클릭!  

    대충 MY-SMTP 정도로 이름을 지어서 [생성] 버튼을 클릭해주도록 합니다.   아래처럼, '기기용 앱 비밀번호'가 생성되는데, 잘 메모해두도록 합니다. 이 기기용 앱 비밀번호가 G메일 SMTP를 이용해서 메일링을 할 때 계정에 로그인하는 pw가 됩니다.

  아래와 같이 MY-SMTP 라는 이름의 App이 생성되었습니다.  

그리고 SMTP 발송에 필요한 정보들을 변수에 담아, 코딩해서 활용하시면 되지 않을까 싶습니다.

# GMAIL SMTP
spring.mail.host = smtp.gmail.com
spring.mail.port = 587
spring.mail.username = ${SMTP_USER}
spring.mail.password = ${SMTP_PASSWORD}
spring.mail.properties.mail.smtp.auth = true
spring.mail.properties.mail.smtp.starttls.enable = true

• 인증 성공 시 2가지 token을 생성

• HttpResponse의 header 부분에 access token 과 refresh token을 추가

  protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) {
        User user = ((UserDetailsImpl) authResult.getPrincipal()).getUser();
        String userId = user.getUserId();
  
        // 토큰 생성시 유효기간 차이를 두고 생성
        String token = jwtService.createToken(userId);
        String refreshToken = jwtService.createRefreshToken(userId);
  
        // 헤더의 이름을 변경해서 2가지 토큰을 response header에 추가
        response.addHeader(JwtService.AUTHORIZATION_HEADER, token);
        response.addHeader(JwtService.REFRESH_TOKEN_HEADER, refreshToken);
  
        user.setRefreshToken(refreshToken);
        userRepository.save(user);
    }

• 동시에 생성된 refresh token을 사용자 엔티티에 추가 -> 데이터 베이스에 refresh token이 저장됨

• 이후 인가 단계에서 access token 만료시, refresh token에 대한 검증 단계를 추가 -> refresh token의 존재여부 (isNull) -> 사용자의 토큰 (DB) HttpResponse에 담겼던 토큰이 같은지

  //JwtAuthorizationFilter.java
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain filterChain) throws ServletException, IOException {
        ...
            String userRefreshToken = jwtService.substringToken(user.getRefreshToken());
            String refreshToken = jwtService.getRefreshJwtFromHeader(req);
  
            log.info("User's Refresh Token: " + userRefreshToken);
            log.info("response's Refresh Token: " + refreshToken);
  
            // 유저가 보유한 토큰과 httpservlet의 토큰이 같은지 비교
            if (userRefreshToken.equals(refreshToken)) {
                // 토큰이 만료된 경우
                if (jwtService.isTokenExpired(tokenValue)) {
                    // 리프레시 토큰이 유효한 경우, 새로운 토큰 생성
                    if (!jwtService.isRefreshTokenExpired(userRefreshToken)) {
                        jwtService.createToken(user.getUserId());
                        System.out.println("jwtService.createToken(user.getUserId()) = " + jwtService.createToken(user.getUserId()));
                        jwtService.createRefreshToken(user.getUserId());
                        log.info("새로운 토큰이 생성되었습니다.");
                        setAuthentication(claims.getSubject());
                        filterChain.doFilter(req, res);
                    } else {
                        // 리프레시 토큰도 만료된 경우
                        throw new IllegalArgumentException("다시 재로그인해주세요");
                    }
                } else {
                    // 토큰이 유효한 경우
                    setAuthentication(claims.getSubject());
                }
            } else {
                throw new IllegalArgumentException("토큰의 정보가 일치하지 않습니다.");
            }
        }
        ...

Access Token 만을 통한 인증 방식의 문제는 만일 제 3자에게 탈취당할 경우 보안에 취약하다는 점이다.

Access Token은 발급된 이후, 서버에 저장되지 않고 토큰 자체로 검증을 하며 사용자 권한을 인증하기 떄문에, Access Token이 탈취되면 토큰이 만료되기 전 까지, 토큰을 획득한 사람은 누구나 권한 접근이 가능해 지기 때문이다.

JWT는 발급한 후 삭제가 불가능하기 때문에, 접근에 관여하는 토큰에 유효시간을 부여하는 식으로 탈취 문제에 대해 대응을 하여야 한다.

이처럼 토큰 유효기간을 짧게하면 토큰 남용을 방지하는 것이 해결책이 될 수 있지만, 유효기간이 짧은 Token의 경우 그만큼 사용자는 로그인을 자주 해서 새롭게 Token을 발급받아야 하므로 불편하다는 단점이 있다. 그렇다고 무턱대고 유효기간을 늘리자면, 토큰을 탈취당했을 때 보안에 더 취약해지게 된다.

이때 “그러면 유효기간을 짧게 하면서  좋은 방법이 있지는 않을까?”라는 질문의 답이 바로 Refresh Token이다.

  이름이 다르지만 형태 자체는 Refresh Token은 Access Token과 똑같은 JWT다. 단지 Access Token은 접근에 관여하는 토큰이고, Refresh Token은 재발급에 관여하는 토큰 이므로 행하는 역할이 다르다고 보면 된다.

예를 들면 처음에 로그인을 했을 때, 서버는 로그인을 성공시키면서 클라이언트에게 Access Token과 Refresh Token을 동시에 발급한다.  서버는 데이터베이스에 Refresh Token을 저장하고, 클라이언트는 Access Token과 Refresh Token을 쿠키, 세션 혹은 웹스토리지에 저장하고 요청이 있을때마다 이 둘을 헤더에 담아서 보낸다.

이 Refresh Token은 긴 유효기간을 가지면서, Access Token이 만료됐을 때 새로 재발급해주는 열쇠가 된다. 따라서 만일 만료된 Access Token을 서버에 보내면, 서버는 같이 보내진 Refresh Token을  DB에 있는 것과 비교해서 일치하면 다시 Access Token을 재발급하는 간단한 원리이다. 그리고 사용자가 로그아웃을 하면 저장소에서 Refresh Token을 삭제하여 사용이 불가능하도록 하고 새로 로그인하면 서버에서 다시 재발급해서 DB에 저장한다.

Access / Refresh Token 재발급 원리

1. 기본적으로 로그인 같은 과정을 하면 Access Token과 Refresh Token을 모두 발급한다. 이때, Refresh Token만 서버측의 DB에 저장하며, Refresh Token과 Access Token을 쿠키 혹은 웹스토리지에 저장한다.  

2. 사용자가 인증이 필요한 API에 접근하고자 하면, 가장 먼저 토큰을 검사한다. 이때, 토큰을 검사함과 동시에 각 경우에 대해서 토큰의 유효기간을 확인하여 재발급 여부를 결정한다.

   case1 : access token과 refresh token 모두가 만료된 경우 → 에러 발생 (재 로그인하여 둘다 새로 발급) case2 : access token은 만료됐지만, refresh token은 유효한 경우 →  refresh token을 검증하여 access token 재발급 case3 : access token은 유효하지만, refresh token은 만료된 경우 →  access token을 검증하여 refresh token 재발급 case4 : access token과 refresh token 모두가 유효한 경우 → 정상 처리

3. 로그아웃을 하면 Access Token과 Refresh Token을 모두 만료시킨다.

Refresh Token 인증 과정

1. 사용자가 ID , PW를 통해 로그인.

2. 서버에서는 회원 DB에서 값을 비교

3~4. 로그인이 완료되면 Access Token, Refresh Token을 발급한다. 이때 회원DB에도 Refresh Token을 저장해둔다.

5. 사용자는 Refresh Token은 안전한 저장소에 저장 후, Access Token을 헤더에 실어 요청을 보낸다.

6~7. Access Token을 검증하여 이에 맞는 데이터를 보낸다.

8. 시간이 지나 Access Token이 만료됐다.

9. 사용자는 이전과 동일하게 Access Token을 헤더에 실어 요청을 보낸다.

10~11. 서버는 Access Token이 만료됨을 확인하고 권한없음을 신호로 보낸다.

12. 사용자는 Refresh Token과 Access Token을 함께 서버로 보낸다.

13. 서버는 받은 Access Token이 조작되지 않았는지 확인한후, Refresh Token과 사용자의 DB에 저장되어 있던 Refresh Token을 비교한다. Token이 동일하고 유효기간도 지나지 않았다면 새로운 Access Token을 발급해준다.

14. 서버는 새로운 Access Token을 헤더에 실어 다시 API 요청 응답을 진행한다. 

출처: https://inpa.tistory.com/entry/WEB-📚-Access-Token-Refresh-Token-원리-feat-JWT [Inpa Dev 👨‍💻:티스토리]