본문 바로가기
SpringBoot

[스프링 부트 3 백엔드 개발자 되기] ch 9. JWT로 로그인/로그아웃 구현하기

쥬크버그 2024. 7. 24. 18:52

1. 토큰 기반 인증 

 

- 사용자가 서버에 접근할 때 이 사용자가 인증된 사용자인지 확인하는 방법은 서버 기반 인증과 토큰 기반 인증이 있다. 

- 스프링 시큐리티에서는 기본적으로 세션 기반 인증을 제공해준다. 

- 토큰 기반 인증은 토큰을 사용하는 방법이다. 

- 토큰은 서버에서 클라이언트를 구분하기 위한 유일한 값인데 서버가 토큰을 생성해서 클라이언트에게 제공하면, 클라이언트는 이 토큰을 갖고 있다가 여러 요청을 이 토큰과 함께 신청한다. 그럼 서버는 토큰만 보고 유효한 사용자인지 검증한다. 

 

토큰을 전달하고 인증받는 과정 

 

 

1)

- 클라이언트가 아이디와 비밀번호를 서버에게 전달하면서 인증을 요청

 

2)

- 서버는 아이디와 비밀번호를 확인해 유효한 사용자인지 검증

- 유효한 사용자면 토큰을 생성해서 응답 

 

3)

- 클라이언트는 서버에서 준 토큰을 저장

 

4)

- 이후 인증이 필요한 API를 사용할 떄 토큰을 함께 보냄

 

5)

- 서버는 토큰이 유효한지 검증

 

6)

- 토큰이 유효하다면 클라이언트가 요청한 내용을 처리 

 

 

토큰 기반 인증의 특징 

 

무상태성

 

- 사용자의 인증정보가 담겨 있는 토큰이 서버가 아닌 클라이언트에 있으므로 서버에 저장할 필요가 없다. 

- 클라이언트에서 인증 정보가 담긴 토큰을 생성하고 인증하므로 클라이언트에서는 사용자의 인증 상태를 유지하면서 이후 요청을 처리해야 하는데 이것을 상태를 관리한다고 한다. 

- 이렇게 하면 서버 입장에서는 클라이언트의 인증 정보를 저장하거나 유지하지 않아도 되기 때문에 완전한 무상태(stateless)로 효율적인 검증을 할 수 있다. 

 

 

확장성 

 

- 서버를 확장할 떄 상태 관리를 신경 쓸 필요가 없으니 서버 확장에도 용이하다

ex)

물건을 파는 서비스가 있고, 결제를 위한 서버와 주문을 위한 서버가 분리되어 있을 때 

 -> 가지고 있는 하나의 토큰으로 결제 서버와 주문 서버에게 요청을 보낼 수 있다. 

- 페이스북 로그인, 구글 로그인과 같이 토큰 기반 인증을 사용하는 다른 시스템에 접근해 로그인 방식을 확장할 수도 있고, 이를 활용해 다른 서비스에 권한을 공유할 수도 있다. 

 

무결성

 

- 토큰 방식은 HMAC(hash-based message authentication) 기법이라 부른다.

- 토큰을 발급한 이후에는 토큰 정보를 변경하는 행위를 할 수 없다. 즉, 토큰의 무결성이 보장된다. 

 

 

1) JWT

 

- 발급받은 JWT를 이용해 인증을 하려면 HTTP 요청 헤더 중에 Authorization 키값에 Bearer+JWT 토큰값을 넣어 보내야 한다. 

 

- JWT는 .을 기준으로 헤더(header), 내용(payload), 서명(signature)으로 이루어져 있다. 

 

헤더

 

- 토큰의 타입과 해싱 알고리즘을 지정하는 정보를 담는다. 

 

이름 설명
typ 토큰의 타입을 지정, JWT라는 문자열이 들어가게 됨
alg 해싱 알고리즘을 지정 

 

ex) 토큰 타입과 해싱 알고리즘 지정 

{
    "type":"JWT",
    "alg":"HS256"
 }

 

 

내용

 

- 토큰과 관련된 정보를 담는다. 

- 내용의 한 덩어리를 클레임(claim)이라 부르며, 클레임은 키값의 한 쌍으로 되어있다. 

- 클레임은 등록된 클레임, 공개 클레임, 비공개 클레임으로 나눌 수 있다. 

 

등록된 클레임(registered claim)

 

- 토큰에 대한 정보를 담는 데 사용 

이름 설명
iss 토큰 발급자(issuer)
sub 토큰 제목(subject)
aud 토큰 대상자(audience)
exp 토큰의 만료 시간(expiraton), 시간은 NumericDate 형식으로 하며, 항상 현재 시간 이후로 설정
nbf 토큰의 활성 날짜와 비슷한 개념으로 nbf는 Not Before을 의미한다. 
iat 토큰이 발급된 시간으로 iat는 issued at을 의미한다. 
jti JWT는 고유 식별자로서 주로 일회용 토큰에 사용한다. 

 

 

공개 클레임(public claim)

 

- 공개되어도 상관없는 클레임

- 충돌을 방지할 수 있는 이름을 가져야 하며, 보통 클레임 이름은 URI로 짓는다. 

 

비공개 클레임(private claim)

 

- 공개되면 안되는 클레임

- 클라이언트와 서버 간의 통신에 사용 

 

서명

 

- 해당 토큰이 조작되었거나 변경되지 않았음을 확인하는 용도로 사용하며, 헤더의 인코딩 값과 내용의 인코딩 값을 합친 후에 주어진 비밀키를 사용해 해시값을 생성 

 

 

리프레시 토큰 

 

- 사용자를 인증하기 위한 용도가 아닌 액세스 토큰이 만료되었을 때 새로운 액세스 토큰을 발급하기 위해 사용 

 

 

1)

- 클라이언트가 서버에게 인증을 요청

 

2)

- 서버는 클라이언트에서 전달한 정보를 바탕으로 인증 정보가 유효한지 확인한 뒤, 액세스 토큰과 리프레시 토큰을 만들어 클라이언트에게 전달. 클라이언트는 전달받은 토큰을 저장한다. 

 

3)

- 서버에서 생성한 리프레시 토큰은 DB에도 저장해둔다. 

 

4)

- 인증을 필요로 하는 API를 호출할 때 클라이언트에 저장된 액세스 토큰과 함께 API를 요청한다. 

 

5)

- 서버는 전달받은 액세스 토큰이 유효한지 검사한 뒤에 유효하다면 클라이언트에서 요청한 내용을 처리 

 

6)

- 시간이 지나고 액세스 토큰이 만료된 뒤에 클라이언트에서 원하는 정보를 얻기 위해 서버에게 API 요청을 보낸다. 

 

7) 

- 서버는 액세스 토큰이 유효한지 검사한다. 만료된 토큰이면 유호하지 않기 때문에 토큰이 만료되었다는 에러를 전달 

 

8)

- 클라이언트는 이 응답을 받고 저장해둔 리프레시 토큰과 함께 새로운 액세스 토큰을 발급하는 요청을 전송한다. 

 

9)

- 서버는 전달받은 리프레시 토큰이 유효한지, DB에서 리프레시 토큰을 조회한 후 저장해둔 리프레시 토큰과 같은지 확인한다. 

 

10)

- 만약 유효한 리프레시 토큰이라면 새로운 액세스 토큰을 생성한 뒤 응답한다. 

 

 

2. JWT 서비스 구현하기 

 

1) 의존성 추가 

 

build.gradle

...
//자바 JWT 라이브러리 
implementation 'io.jsonwebtoken:jjwt:0.9.1'
//XML 문서와 Java 객체 간 매핑 자동화 
implementation 'javax.xml.bind:jaxb-api:2.3.1'
...

 

 

2) 토큰 제공자 추가하기 

 

- jwt를 사용해서 JWT를 생성하고 유효한 토큰인지 검증하는 역할을 하는 클래스 추가 

 

application.yml

 

- JWT 토큰을 만들려면 이슈 발급자(issuer), 비밀키(secret_key)를 필수로 지정해야 한다. 

spring:
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true
    defer-datasource-initialization: true
  datasource: # 1. 데이터베이스 정보 추가
    url: jdbc:h2:mem:testdb
    username: sa
  h2: # 2. 콘솔 활성화
    console:
      enabled: true

  jwt:
    issuer:ajufresh@gmail.com 
    secret_key:study-springboot

 

 

 

config/jwt/JwtProperties.java

 

- 해당 값들을 변수로 접근하는 데 사용할 JwtProperties 클래스를 만든다. 

- issuer 필드에는 application.yml에서 설정한 jwt.issuer 값이, secret_key에는 jwt.secret_key값이 매핑된다. 

@Setter
@Getter
@Component
@ConfigurationProperties("jwt") //자바 클래스에 프로퍼티값을 가져와서 사용하는 애너테이션
public class JwtProperties {

    private String issuer;
    private String secret_key;
}

 

 

config/jwt/TokenProvider.java

@RequiredArgsConstructor
@Service
public class TokenProvider {

    private final JwtProperties jwtProperties;

    public String generateToken(User user, Duration expiredAt) {
        Date now = new Date();
        return makeToken(new Date(now.getTime() + expiredAt.toMillis()), user);
    }

    
    //1. JWT 토큰 생성 메서드 
    private String makeToken(Date expiry, User user) {
        Date now = new Date();

        return Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE) //헤더 typ:JWT
                .setIssuer(jwtProperties.getIssuer()) //내용 iss
                .setIssuedAt(now) //내용 exp
                .setExpiration(expiry) //내용 exp
                .setSubject(user.getEmail()) //내용 sub
                .claim("id", user.getId()) //클레임 id : 유저 ID
                //서명 : 비밀값과 함께 해시값을 HS256 방식으로 암호화 
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecret_key())
                .compact();
    }

    //2.JWT 토큰 유효성 검증 메서드 
    public boolean validToken(String token) {
        try {
            Jwts.parser()
                    .setSigningKey(jwtProperties.getSecret_key()) //비밀값으로 복호화 
                    .parseClaimsJws(token);

            return true;
        } catch (Exception e) { //복호화 과정에서 에러가 나면 유효하지 않은 토큰 
            return false;
        }
    }


    //3. 토큰 기반으로 인증 정보를 가져오는 메서드 
    public Authentication getAuthentication(String token) {
        Claims claims = getClaims(token);
        Set<SimpleGrantedAuthority> authorities = Collections.singleton(new SimpleGrantedAuthority("ROLE_USER"));

        return new UsernamePasswordAuthenticationToken(new org.springframework.security.core.userdetails.User(claims.getSubject
                (), "", authorities), token, authorities);
    }

    //토큰 기반으로 유저 ID를 가져오는 메서드 
    public Long getUserId(String token) {
        Claims claims = getClaims(token);
        return claims.get("id", Long.class);
    }

    private Claims getClaims(String token) {
        return Jwts.parser() //클레임 조회 
                .setSigningKey(jwtProperties.getSecret_key())
                .parseClaimsJws(token)
                .getBody();
    }
}

 

1)

- 토큰을 생성하는 메서드 

- 인자는 만료 시간, 유저 정보를 받는다. 

 

2) 

- 토큰이 유효한지 검증한느 메서드 

- 프로퍼티즈 파일에 선언한 비밀값과 함께 토큰 복호화를 진행한다. 

 

3)

- 토큰을 받아 인증 정보를 담은 객체 Authentication을 반환하는 메서드 

- 프로퍼티즈 파일에 저장한 비밀값으로 토큰을 복호화한 뒤 클레임을 가져오는 private 메서드인 getClaims()를 호출해서 클레임 정보를 반환받아 사용자 이메일이 들어 있는 토큰 제목 sub와 토큰 기반으로 인증 정보를 생성 

 

4)

- 토큰 기반으로 사용자 ID를 가져오는 메서드

- 프로퍼티즈 파일에 저장한 비밀값으로 토큰을 복호화한 다음 클레임을 가져오는 private 메서드인 getClaims()를 호출해서 클레임 정보를 반환받고 클레임에서 id 키로 저장된 값을 가져와 봔환 

 

 

test/config.jwt/JwtFactory

- 코드가 제대로 동작하는지 확인하기 위해 테스트 코드 작성 

@Getter
public class JwtFactory {

    private String subject = "test@email.com";

    private Date issuedAt = new Date();

    private Date expiration = new Date(new Date().getTime() + Duration.ofDays(14).toMillis());

    private Map<String, Object> claims = emptyMap();

    //빌더 패턴을 사용해 설정이 필요한 데이터만 선택 설정
    @Builder
    public JwtFactory(String subject, Date issuedAt, Date expiration,
                      Map<String, Object> claims) {
        this.subject = subject != null ? subject : this.subject;
        this.issuedAt = issuedAt != null ? issuedAt : this.issuedAt;
        this.expiration = expiration != null ? expiration : this.expiration;
        this.claims = claims != null ? claims : this.claims;
    }

    public static JwtFactory withDefaultValues() {
        return JwtFactory.builder().build();
    }

    //jjwt 라이브러리를 사용해 JWT 토큰 생성
    public String createToken(JwtProperties jwtProperties) {
        return Jwts.builder()
                .setSubject(subject)
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE)
                .setIssuer(jwtProperties.getIssuer())
                .setIssuedAt(issuedAt)
                .setExpiration(expiration)
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecret_key())
                .compact();
    }
}

 

 

TokenProvider.java

@SpringBootTest
class TokenProviderTest {

    @Autowired
    private TokenProvider tokenProvider;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private JwtProperties jwtProperties;

    //1. generateToken() 검증 테스트
    @DisplayName("generateToken(): 유저 정보와 만료 기간을 전달해 토큰을 만들 수 있다.")
    @Test
    void generateToken() {
        // given
        User testUser = userRepository.save(User.builder()
                .email("user@gmail.com")
                .password("test")
                .build());

        // when
        String token = tokenProvider.generateToken(testUser, Duration.ofDays(14));

        // then
        Long userId = Jwts.parser()
                .setSigningKey(jwtProperties.getSecret_key())
                .parseClaimsJws(token)
                .getBody()
                .get("id", Long.class);

        assertThat(userId).isEqualTo(testUser.getId());
    }

    //2.validToken() 검증 테스트
    @DisplayName("validToken(): 만료된 토큰인 경우에 유효성 검증에 실패한다.")
    @Test
    void validToken_invalidToken() {
        // given
        String token = JwtFactory.builder()
                .expiration(new Date(new Date().getTime() - Duration.ofDays(7).toMillis()))
                .build()
                .createToken(jwtProperties);

        // when
        boolean result = tokenProvider.validToken(token);

        // then
        assertThat(result).isFalse();
    }

    @DisplayName("validToken(): 유효한 토큰인 경우에 유효성 검증에 성공한다.")
    @Test
    void validToken_validToken() {
        // given
        String token = JwtFactory.withDefaultValues()
                .createToken(jwtProperties);

        // when
        boolean result = tokenProvider.validToken(token);

        // then
        assertThat(result).isTrue();
    }


    //3.getAuthentication() 검증 테스트
    @DisplayName("getAuthentication(): 토큰 기반으로 인증정보를 가져올 수 있다.")
    @Test
    void getAuthentication() {
        // given
        String userEmail = "user@email.com";
        String token = JwtFactory.builder()
                .subject(userEmail)
                .build()
                .createToken(jwtProperties);

        // when
        Authentication authentication = tokenProvider.getAuthentication(token);

        // then
        assertThat(((UserDetails) authentication.getPrincipal()).getUsername()).isEqualTo(userEmail);
    }

    //4.getUserId() 검증 테스트 
    @DisplayName("getUserId(): 토큰으로 유저 ID를 가져올 수 있다.")
    @Test
    void getUserId() {
        // given
        Long userId = 1L;
        String token = JwtFactory.builder()
                .claims(Map.of("id", userId))
                .build()
                .createToken(jwtProperties);

        // when
        Long userIdByToken = tokenProvider.getUserId(token);

        // then
        assertThat(userIdByToken).isEqualTo(userId);
    }
}

 

 

generateToken() 메서드 

 

//1. generateToken() 검증 테스트
    @DisplayName("generateToken(): 유저 정보와 만료 기간을 전달해 토큰을 만들 수 있다.")
    @Test
    void generateToken() {
        // given
        User testUser = userRepository.save(User.builder()
                .email("user@gmail.com")
                .password("test")
                .build());

        // when
        String token = tokenProvider.generateToken(testUser, Duration.ofDays(14));

        // then
        Long userId = Jwts.parser()
                .setSigningKey(jwtProperties.getSecret_key())
                .parseClaimsJws(token)
                .getBody()
                .get("id", Long.class);

        assertThat(userId).isEqualTo(testUser.getId());
    }
given 토큰에 유저 정보를 추가하기 위한 테스트 유저를 만든다. 
when 토큰 제공자의 generateToken() 메서드를 호출해 토큰을 만든다. 
then jjwt 라이브러리를 사용해 토큰을 복호화한다. 토큰을 만들 떄 클레임으로 넣어둔 id값이 given절에서 만든 유저 ID와 동일한지 확인 

 

 

 validToken_invalidToken() 메서드 

 

 //2.validToken() 검증 테스트
    @DisplayName("validToken(): 만료된 토큰인 경우에 유효성 검증에 실패한다.")
    @Test
    void validToken_invalidToken() {
        // given
        String token = JwtFactory.builder()
                .expiration(new Date(new Date().getTime() - Duration.ofDays(7).toMillis()))
                .build()
                .createToken(jwtProperties);

        // when
        boolean result = tokenProvider.validToken(token);

        // then
        assertThat(result).isFalse();
    }

    @DisplayName("validToken(): 유효한 토큰인 경우에 유효성 검증에 성공한다.")
    @Test
    void validToken_validToken() {
        // given
        String token = JwtFactory.withDefaultValues()
                .createToken(jwtProperties);

        // when
        boolean result = tokenProvider.validToken(token);

        // then
        assertThat(result).isTrue();
    }

 

- 검증 실패를 확인하는 validToken_invalidToken() 메서드와 검증 성공을 의미하는 validToken_validToken() 메서드가 있다. 

 

given jjwt 라이브러리를 사용해 토큰을 생성
이때 만료시간은 1970년 1월 1일부터 현재 시간을 밀리초 단위로 치환한 값(new Date().getTime())에 1000을 빼, 이미 만료된 토큰으로 생성
when 토큰 제공자의 validToken() 메서드를 호출해 유효한 토큰인지 검증한 뒤 결괏값을 반환받는다. 
then 반환값이 false(유효한 토큰이 아님)인 것을 확인한다. 

 

given jjwt 라이브러리를 사용해 토큰을 생성
만료 시간은 현재 시간으로부터 14일 뒤로, 만료되지 않은 토큰으로 생성
when 토큰 제공자의 validToken() 메서드를 호출해 유효한 토큰인지 검증한 뒤 결괏값을 반환받는다. 
then 반환값이 true(유효한 토큰)인 것을 확인한다. 

 

 

getAuthentication() 메서드 

 

- 토큰을 전달받아 인증 정보를 담은 객체 Authentication을 반환하는 메서드인 getAuthentication()을 테스트 

//3.getAuthentication() 검증 테스트
    @DisplayName("getAuthentication(): 토큰 기반으로 인증정보를 가져올 수 있다.")
    @Test
    void getAuthentication() {
        // given
        String userEmail = "user@email.com";
        String token = JwtFactory.builder()
                .subject(userEmail)
                .build()
                .createToken(jwtProperties);

        // when
        Authentication authentication = tokenProvider.getAuthentication(token);

        // then
        assertThat(((UserDetails) authentication.getPrincipal()).getUsername()).isEqualTo(userEmail);
    }

 

given jjwt 라이브러리를 사용해 토큰을 생성
토큰의 제목인 subject인 "user@email.com"라는 값을 사용
when 토큰 제공자의 getAuthenticaiton() 메서드를 호출해 인증 객체를 반환받음
then 반환받은 인증 객체의 유저 이름을 가져와 given 절에서 설정한 subject값인 "user@email.com"과 같은지 확인 

 

 

getUserId() 메서드 

 

- 토큰 기반으로 유저 ID를 가져오는 메서드를 테스트하는 메서드 

//4.getUserId() 검증 테스트
    @DisplayName("getUserId(): 토큰으로 유저 ID를 가져올 수 있다.")
    @Test
    void getUserId() {
        // given
        Long userId = 1L;
        String token = JwtFactory.builder()
                .claims(Map.of("id", userId))
                .build()
                .createToken(jwtProperties);

        // when
        Long userIdByToken = tokenProvider.getUserId(token);

        // then
        assertThat(userIdByToken).isEqualTo(userId);
    }

 

given jjwt 라이브러리를 사용해 토큰을 생성 
이때 클레임을 추가한다. 
키는 "id", 값은 1이라는 유저 ID이다. 
when 토큰 제공자의 getUserId() 메서드를 호출해 유저 ID를 반환받는다. 
then 반환받는 유저 ID가 given절에서 설정한 유저 ID값인 1과 같은지 확인 

 

 

3) 리프레시 토큰 도메인 구현하기 

 

- 리프레시 토큰은 데이터베이스에 저장되는 정보이므로 엔티티와 리포지터리를 추가해야 한다. 

 

컬럼명 자료형 null 허용 키 설명
id BIGINT N 기본키 일련번호, 기본키
user_id BIGINT N   유저 ID
refresh_token VARCHAR(255) N   토큰값

 

 

domain/RefreshToken.java

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Entity
public class RefreshToken {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", updatable = false)
    private Long id;

    @Column(name = "user_id", nullable = false, unique = true)
    private Long userId;

    @Column(name = "refresh_token", nullable = false)
    private String refreshToken;

    public RefreshToken(Long userId, String refreshToken) {
        this.userId = userId;
        this.refreshToken = refreshToken;
    }

    public RefreshToken update(String newRefreshToken) {
        this.refreshToken = newRefreshToken;
        return this;
    }
}

 

 

RefreshRepository.java

public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
    Optional<RefreshToken> findByUserId(Long userId);
    Optional<RefreshToken> findByRefreshToken(String refreshToken);
}

 

 

4) 토큰 필터 구현하기 

 

- 필터는 실제로 각종 요청을 처리하기 위한 로직으로 전달되기 전후에 URL 패턴에 맞는 모든 요청을 처리하는 기능을 제공한다. 

- 요청이 오면 헤더값을 비교해서 토큰이 있는지 확인하고 유효 토큰이라면 시큐리티 콘텍스트 홀더(security context holder)에 인증정보를 저장한다. 

 

- 시큐리티 컨텍스트(security context)는 인증 객체가 저장되는 보관소이다. 여기서 인증 정보가 필요할 때 언제든지 인증 객체를 꺼내 사용할 수 있다. 

- 이 클래스는 스레드마다 공간을 할당하는 즉, 스레드 로컬(thread local)에 저장되므로 코드 아무 곳에서나 참조할 수 있고, 다른 스레드와 공유하지 않으므로 독립적으로 사용할 수 있다. 이러한 컨텍스트 객체를 저장하는 객체가 시큐리티 컨텍스트 홀더(security context holder)이다. 

 

 

 

config/TokenAuthenticationFilter.java

@RequiredArgsConstructor
public class TokenAuthenticationFilter extends OncePerRequestFilter {
    private final TokenProvider tokenProvider;
    private final static String HEADER_AUTHORIZATION = "Authorization";
    private final static String TOKEN_PREFIX = "Bearer ";
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        //요청 헤더의 Authorization 키의 값 조회 
        String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);
        //가져온 값에서 접두사 제거 
        String token = getAccessToken(authorizationHeader);

        //가져온 토큰이 유효한지 확인하고, 유효한 때는 인증 정보 설정 
        if (tokenProvider.validToken(token)) {
            Authentication authentication = tokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        filterChain.doFilter(request, response);
    }
    private String getAccessToken(String authorizationHeader) {
        if (authorizationHeader != null && authorizationHeader.startsWith(TOKEN_PREFIX)) {
            return authorizationHeader.substring(TOKEN_PREFIX.length());
        }
        return null;
    }
}

 

- 요청 헤더에서 키가 'Auhorization'인 필드의 값을 가져온 다음 토큰의 접두사 Bearer를 제외한 값을 얻는다. 

- 만약 값이 null이거나 Bearer로 시작하지 않으면 null을 반환한다. 

- 이어서 가져온 토큰이 유효한지 확인하고, 유효하다면 인증 정보를 관리하는 시큐리티 컨텍스트에 인증 정보를 설정한다. 

- 위에서 작성한 코드가 실행되며 인증 정보가 설정된 이후에 컨텍스트 폴더에서 getAuthentication() 메서드를 사용해 인증 정보를 가져오면 유저 객체가 반환된다. 유저 객체에는 유저 이름(username)과 권한목록(authorities)과 같은 인증 정보가 포함된다. 

 

 

3. 토큰 API 구현하기 

 

- 리프레시 토큰을 전달받아 검증하고, 유효한 리프레시 토큰이라면 새로운 액세스 토큰을 생성하는 토큰 API

 

1) 토큰 서비스 추가하기 

 

UserService.java

- 전달받은 유저 ID로 유저를 검색해서 전달하는 findById() 메서드를 추가로 구현 

...
public User findById(Long userId) {
        return userRepository.findById(userId)
                .orElseThrow(()-> new IllegalArgumentException("Unexpected user"));
 }

 

 

service/RefreshTokenService.java

- 전달받은 리프레시 토큰으로 리프레시 토큰 객체를 검색해서 전달하는 findByRefreshToken() 메서드 구현 

@RequiredArgsConstructor
@Service
public class RefreshTokenService {
    private final RefreshTokenRepository refreshTokenRepository;
    
    public RefreshToken findByRefreshToken(String refreshToken) {
        return refreshTokenRepository.findByRefreshToken(refreshToken)
                .orElseThrow(()->new IllegalArgumentException("Unexpected token"))
    }
}

 

 

service/TokenService.java

 

- createNewAccessToken() 메서드는 전달받은 리프레시 토큰으로 토큰 유효성 검사를 진행하고, 유효한 토큰일 때 리프레시 토큰으로 사용자 ID를 찾는다. 마지막으로는 사용자 ID로 사용자를 찾은 후에 토큰 제공자의 generateToken() 메서드를 호출해서 새로운 액세스 토큰을 생성한다. 

 

@RequiredArgsConstructor
@Service
public class TokenService {
    private final TokenProvider tokenProvider;
    private final RefreshTokenService refreshTokenService;
    private final UserService userService;

    public String createNewAccessToken(String refreshToken) {
        //토큰 유효성 검사에 실패하면 예외 발생 
        if(!tokenProvider.validToken(refreshToken)) {
            throw new IllegalArgumentException("Unexpected token");
        }

        Long userId = refreshTokenService.findByRefreshToken(refreshToken).getUserId();
        User user = userService.findById(userId);

        return tokenProvider.generateToken(user, Duration.ofHours(2));
    }
}

 

 

2) 컨트롤러 추가하기 

 

- 실제로 토큰을 발급받는 API 생성 

 

dto/CreateAccessTokenRequest.java

- 토큰 생성 요청 

@Getter
@Setter
public class CreateAccessTokenRequest {
    private String refreshToken;
}

 

dto/CreateAccessTokenResponse.java

- 토큰 생성 응답 

@AllArgsConstructor
@Getter
public class CreateAccessTokenResponse {
    private String accessToken;
}

 

controller/TokenApiController.java

- /api/token POST 요청이 오면 토큰 서비스에서 리프레시 토큰을 기반으로 새로운 액세스 토큰을 만들어 주기 

@RequiredArgsConstructor
@RestController
public class TokenApiController {
    private final TokenService tokenService;

    @PostMapping("/api/token")
    public ResponseEntity<CreateAccessTokenResponse> createNewAccessToken(@RequestBody CreateAccessTokenRequest request) {
        String newAccessToken = tokenService.createNewAccessToken(request.getRefreshToken());

        return ResponseEntity.status(HttpStatus.CREATED)
                .body(new CreateAccessTokenResponse(newAccessToken));
    }
}

 

'SpringBoot' 카테고리의 다른 글

[스프링 부트 3 백엔드 개발자 되기] ch 11. AWS에 프로젝트 배포하기  (0) 2024.07.26
[스프링 부트 3 백엔드 개발자 되기] ch 10. OAuth2로 로그인/로그아웃 구현하기  (0) 2024.07.25
[스프링 부트 3 백엔드 개발자 되기] ch 8. 스프링 시큐리티로 로그인/로그아웃, 회원가입 구현하기  (28) 2024.07.19
[스프링 부트 3 백엔드 개발자 되기] ch 7. 블로그 화면 구성하기  (0) 2024.07.17
[스프링 부트 3 백엔드 개발자 되기] ch 6. 블로그 기획하고 API 만들기  (0) 2024.07.17

'SpringBoot' Related Articles

티스토리툴바