feat : OAuth2.0 카카오 로그인 & JWT 인증 구현

build.gradle

@@ -49,6 +49,8 @@ dependencies {
     asciidoctorExt 'org.springframework.restdocs:spring-restdocs-asciidoctor'
     testImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'
 
+    testCompileOnly 'org.projectlombok:lombok'
+    testAnnotationProcessor 'org.projectlombok:lombok'
 }
 
 tasks.named('test') {

src/main/java/com/prgrms/catchtable/common/Role.java

@@ -0,0 +1,14 @@
+package com.prgrms.catchtable.common;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum Role {
+
+    MEMBER("ROLE_MEMBER"),
+    OWNER("ROLE_OWNER");
+
+    private final String role;
+}

src/main/java/com/prgrms/catchtable/jwt/config/JwtConfig.java

@@ -0,0 +1,16 @@
+package com.prgrms.catchtable.jwt.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Component
+@Data
+@ConfigurationProperties(prefix = "jwt")
+public class JwtConfig {
+
+    private String clientSecret;
+    private int expiryMinute;
+    private int expiryMinuteRefresh;
+
+}

src/main/java/com/prgrms/catchtable/jwt/domain/RefreshToken.java

@@ -0,0 +1,35 @@
+package com.prgrms.catchtable.jwt.domain;
+
+import static lombok.AccessLevel.PROTECTED;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor(access = PROTECTED)
+@Entity
+public class RefreshToken {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "token")
+    private String token;
+
+    @Column(name = "email")
+    private String email;
+
+    @Builder
+    public RefreshToken(String token, String email) {
+        this.token = token;
+        this.email = email;
+    }
+
+}

src/main/java/com/prgrms/catchtable/jwt/filter/JwtAuthenticationFilter.java

@@ -0,0 +1,64 @@
+package com.prgrms.catchtable.jwt.filter;
+
+import com.prgrms.catchtable.jwt.domain.RefreshToken;
+import com.prgrms.catchtable.jwt.provider.JwtTokenProvider;
+import com.prgrms.catchtable.jwt.service.RefreshTokenService;
+import com.prgrms.catchtable.jwt.token.Token;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.GenericFilter;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class JwtAuthenticationFilter extends GenericFilter {
+
+    private final JwtTokenProvider jwtTokenProvider;
+
+    private final RefreshTokenService refreshTokenService;
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+        throws IOException, ServletException {
+
+        String accessToken = ((HttpServletRequest) request).getHeader("AccessToken");
+        String refreshToken = ((HttpServletRequest) request).getHeader("RefreshToken");
+
+        if (accessToken != null) {
+            //AccessToken 유효
+            if (jwtTokenProvider.validateToken(accessToken)) {
+                setAuthentication(accessToken);
+            }
+            //RefreshToken 유효
+            else {
+                if (jwtTokenProvider.validateToken(refreshToken)) {
+                    RefreshToken refreshTokenEntity = refreshTokenService.getRefreshTokenByToken(
+                        refreshToken);
+                    String email = refreshTokenEntity.getEmail();
+                    Token newToken = jwtTokenProvider.createToken(email);
+
+                    ((HttpServletResponse) response).setHeader("AccessToken",
+                        newToken.getAccessToken());
+                    setAuthentication(newToken.getAccessToken());
+                } else {
+                    throw new UsernameNotFoundException("Please Login again");
+                }
+            }
+        }
+        chain.doFilter(request, response);
+    }
+
+    private void setAuthentication(String accessToken) {
+        Authentication authentication = jwtTokenProvider.getAuthentication(accessToken);
+        SecurityContextHolder.getContext().setAuthentication(authentication);
+    }
+}

src/main/java/com/prgrms/catchtable/jwt/provider/JwtTokenProvider.java

@@ -0,0 +1,90 @@
+package com.prgrms.catchtable.jwt.provider;
+
+
+import com.prgrms.catchtable.jwt.config.JwtConfig;
+import com.prgrms.catchtable.jwt.service.JwtUserDetailsService;
+import com.prgrms.catchtable.jwt.token.Token;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import java.util.Date;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class JwtTokenProvider {
+
+    private final JwtConfig jwtConfig;
+
+    private final JwtUserDetailsService jwtUserDetailsService;
+
+    public Token createToken(String email) {
+
+        Claims claims = Jwts.claims().setSubject(email);
+        Date now = new Date();
+
+        String accessToken = createAccessToken(claims, now);
+        String refreshToken = createRefreshToken(claims, now);
+
+        return new Token(accessToken, refreshToken, email);
+    }
+
+    private String createAccessToken(Claims claims, Date now) {
+        long expiryMinute = jwtConfig.getExpiryMinute() * 1000L * 60;
+
+        return Jwts.builder()
+            .setClaims(claims)
+            .setIssuedAt(now)
+            .setExpiration(new Date(now.getTime() + expiryMinute))
+            .signWith(SignatureAlgorithm.HS256, jwtConfig.getClientSecret())
+            .compact();
+    }
+
+    private String createRefreshToken(Claims claims, Date now) {
+
+        long expiryMinuteRefresh = jwtConfig.getExpiryMinuteRefresh() * 1000L * 60;
+
+        return Jwts.builder()
+            .setClaims(claims)
+            .setIssuedAt(now)
+            .setExpiration(new Date(now.getTime() + expiryMinuteRefresh))
+            .signWith(SignatureAlgorithm.HS256, jwtConfig.getClientSecret())
+            .compact();
+    }
+
+    public boolean validateToken(String token) {
+        try {
+            Claims claims = Jwts.parserBuilder()
+                .setSigningKey(jwtConfig.getClientSecret())
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+
+            return claims.getExpiration().after(new Date());
+        } catch (JwtException je) {
+            return false;
+        }
+    }
+
+    public Authentication getAuthentication(String token) {
+        String email = getEmail(token);
+        UserDetails userDetails = jwtUserDetailsService.loadUserByUsername(email);
+        return new UsernamePasswordAuthenticationToken(userDetails, "",
+            userDetails.getAuthorities());
+    }
+
+    private String getEmail(String token) {
+        Claims claims = Jwts.parserBuilder()
+            .setSigningKey(jwtConfig.getClientSecret())
+            .build()
+            .parseClaimsJws(token)
+            .getBody();
+
+        return claims.getSubject();
+    }
+}

src/main/java/com/prgrms/catchtable/jwt/repository/RefreshTokenRepository.java

@@ -0,0 +1,14 @@
+package com.prgrms.catchtable.jwt.repository;
+
+import com.prgrms.catchtable.jwt.domain.RefreshToken;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
+
+    boolean existsRefreshTokenByEmail(String email);
+
+    void deleteRefreshTokenByEmail(String email);
+
+    Optional<RefreshToken> findRefreshTokenByToken(String token);
+}

src/main/java/com/prgrms/catchtable/jwt/service/JwtUserDetailsService.java

@@ -0,0 +1,21 @@
+package com.prgrms.catchtable.jwt.service;
+
+import com.prgrms.catchtable.member.repository.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class JwtUserDetailsService implements UserDetailsService {
+
+    private final MemberRepository memberRepository;
+
+    @Override
+    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
+        return memberRepository.findMemberByEmail(email)
+            .orElseThrow(() -> new UsernameNotFoundException("Not Found Member"));
+    }
+}

src/main/java/com/prgrms/catchtable/jwt/service/RefreshTokenService.java

@@ -0,0 +1,38 @@
+package com.prgrms.catchtable.jwt.service;
+
+import com.prgrms.catchtable.jwt.domain.RefreshToken;
+import com.prgrms.catchtable.jwt.repository.RefreshTokenRepository;
+import com.prgrms.catchtable.jwt.token.Token;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class RefreshTokenService {
+
+    private final RefreshTokenRepository refreshTokenRepository;
+
+    @Transactional
+    public void saveRefreshToken(Token totalToken) {
+        String email = totalToken.getEmail();
+
+        if (refreshTokenRepository.existsRefreshTokenByEmail(email)) {
+            refreshTokenRepository.deleteRefreshTokenByEmail(email);
+        }
+
+        RefreshToken newRefreshToken = RefreshToken.builder()
+            .token(totalToken.getRefreshToken())
+            .email(email)
+            .build();
+
+        refreshTokenRepository.save(newRefreshToken);
+    }
+
+    @Transactional(readOnly = true)
+    public RefreshToken getRefreshTokenByToken(String refreshToken) {
+        return refreshTokenRepository.findRefreshTokenByToken(refreshToken)
+            .orElseThrow(() -> new UsernameNotFoundException("Not Found RefreshToken"));
+    }
+}

src/main/java/com/prgrms/catchtable/jwt/token/Token.java

@@ -0,0 +1,15 @@
+package com.prgrms.catchtable.jwt.token;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class Token {
+
+    private String accessToken;
+
+    private String refreshToken;
+
+    private String email;
+}