Spring Boot Github 소셜 로그인 구현하기 [ RestTemplate · WebClient · FeignClient 를 비교해보자 ]

Github OAuth 인증 흐름과 사전 준비

Github 인증 흐름은 다음과 같다.

1. https://github.com/login/oauth/authorize?client_id={발급받은 client_id} 로 이동하는 링크를 사용자가 클릭한다.
2. 사용자는 아래와 같은 화면이 나타나는 화면으로 이동하고, Github 인증을 한다.

3. 인증을 성공하면 {설정한 콜백 URL}?code={인증코드} 로 code 값을 쿼리 파라미터 형태로 보내준다.
4. 쿼리 파라미터로 전달된 code를 서버에서 받고, https://github.com/login/oauth/access_token 으로 {client_ID, client_Secret, code}를 담아 POST 요청을 한다.
5. 깃허브 측에서 access_token을  서버측으로 응답한다.
6. 받은 access_token 을 https://api.github.com/user로 담아서 GET 요청을 보낸다.
7. 깃허브 측에서 인증한 사용자의 정보를 응답한다.
8. 그렇게 받은 사용자의 정보를 서버측에서 활용한다.

---

구현하기에 앞서,

Settings > Developer settings > New Github App 으로 이동하여 기능 구현을 위한 Client_ID 와 Client_Secret 을 발급받아야 한다.

 

 

Homepage Url은 일단 로컬 환경에서 구현해볼 것이기 때문에 localhost:8080 으로 해두었다.

 

나중에 AWS EC2 로 띄우거나 하면, EC2 주소와 포트번호를 입력해두면 된다.

 

Callback URL은 어떤 사용자가 깃허브 로그인을 성공하면 깃허브 측에서 Code 를 쿼리파라미터로 보내주는데, 그 파라미터를 받을 주소이다.

 

나는 http://localhost:8080/oauth2/redirect 로 설정하였다.

 

http://localhost:8080/oauth2/redirect?code={코드~~} 이런식으로 리다이렉트 될 것이다.

 

정상적으로 등록을 마치면 Client ID 와 Client Secret 정보를 얻을 수 있다.

 

Client Secret은 민감정보이므로 노출되지 않도록 주의한다.

 

application.yml 설정

github:
  client-id:
  client-secret:

 

위와 같은 부분을 추가해준다.

 

 

일단, client-id와 client-secret은 IntellJ 환경변수로 넣어주었다.

 

html 파일

<a class="circle github"
 	th:onclick="'window.open(\'https://github.com/login/oauth/authorize?client_id=' + @{{clientId}(clientId=${@environment.getProperty('github.client-id')})} + '\',\'_self\')'">
<i class="fa fa-github fa-fw"></i>
</a>

 

html 코드는 어떤 방식이든 상관없다.

 

나는 일단 버튼을 클릭하면 https://github.com/login/oauth/authorize?client_id={발급받은 client_id} 로 이동하게끔 했다.

 

타임리프 문법을 활용하면, 환경변수를 얻어와 사용할 수 있기 때문에 위와 같이 만들었다.

 

만약 타임리프를 사용하지 않는다면, html a 태그의 href 방식을 사용하면 될 것이다.

 

---

구현

먼저, 사용자의 깃허브의 사용자명을 받아 DB에 가입된 사용자가 있으면 jwt를 생성해 브라우저 쿠키에 저장하고 

 

아직 가입된 사용자가 아니라면 가입 처리 후, jwt 를 생성해 브라우저 쿠키에 저장하는 방식으로 구현했다.

 

깃허브에서 받아오는 사용자명은 Unique 하기 때문에, 식별하는 용도로 사용할 수 있다고 판단하였다.

 

 

JWT 관련 Enum 정의

public class CookieConstants {
    public static final String JWT_COOKIE_NAME = "jwt";
    public static final int JWT_COOKIE_AGE = 60 * 60;
}

jwt 유효 기간은 60 * 60 초 = 1시간으로 두었다.

 

그리고 쿠키 이름으로 "jwt" 로 저장되게끔 할 것이다.

 

CookieUtil 정의

public class CookieUtil {

    public static void setCookie(HttpServletResponse response, String cookieName, String cookieValue, int cookieAge) {
        ResponseCookie cookie = ResponseCookie.from(cookieName, cookieValue)
                .path("/")
                .httpOnly(true)
                .maxAge(cookieAge)
                .build();

        response.addHeader("Set-Cookie", cookie.toString());
    }
}

HttpServletResponse 객체를 통해 응답 시, 쿠키 이름과 쿠키로 저장될 값 그리고 유효기간을 설정해서 저장되도록하는 메서드이다.

 

Controller 

@Controller
@RequiredArgsConstructor
public class UserJoinController {

    @Value("${github.client-id}")
    private String clientId;

    @Value("${github.client-secret}")
    private String clientSecret;

    private final GithubJoinService githubJoinService;
    
    private final UserJoinService userJoinService;

    @GetMapping("/oauth2/redirect")
    public String githubLogin(@RequestParam String code) {
        String accessToken = githubJoinService.getAccessToken(clientId, clientSecret, code);
        return "redirect:/githubLogin/success?access_token=" + accessToken;
    }

    @GetMapping("/githubLogin/success")
    public String githubLoginSuccess(HttpServletResponse response, @RequestParam(name = "access_token") String accessToken) {
        UserProfile userProfile = githubJoinService.getUserInfo(accessToken);

        String jwt = userJoinService.login(userProfile);

        CookieUtil.setCookie(response, JWT_COOKIE_NAME, jwt, JWT_COOKIE_AGE);

        return "redirect:/";
    }
}

 

먼저 @Value 어노테이션으로 clientId 와 clientSecret 환경변수가 주입될 수 있도록 한다.

 

그리고 사전 설정에서, 사용자가 깃허브 인증을 하면 /oauth2/redirect?code={코드~~} 로 리다이렉트를 하도록 설정했기 때문에

 

githubLogin(@RequestParam String code) 메서드를 정의하였고, 받은 code로 accessToken을 얻어오는 메서드는 GithubJoinService로서 따로 정의할 것이다.

 

정상적으로 accessToken을 받았다면 /githubLogin/success?access_token={받은 access Token} 로 리다이렉트 시키게끔 하였다.

 

그러면 아래 정의한 githubLoginSuccess() 메서드가 동작한다.

 

쿼리 파라미터로서 전달받은 accessToken을 이용해서 회원 정보를 얻어오는 메서드를 만들고, jwt를 발급받아 쿠키에 저장하도록 하면 로그인 과정이 마무리된다.

 

회원 정보로 login 후 jwt 생하는 로직은 이 게시글에서는 생략하겠다.

 

GithubJoinService 인터페이스 정의

Spring으로 할 수 있는 여러가지 REST 요청 방법을 사용할 것이므로 인터페이스로 정의하겠다.

 

public interface GithubJoinService {

    String getAccessToken(@RequestParam String code);

    UserProfile getUserInfo(String accessToken);
}

 

UserProfile 정의

@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class UserProfile {

    @JsonProperty("login")
    private String userName;
    @JsonProperty("avatar_url")
    private String imageUrl;
    private String blog;
    @JsonProperty("html_url")
    private String githubUrl;

}

위와 같이 적용했다.

 

받은 access_token 을 https://api.github.com/user로 담아서 GET 요청을 보내면 아래와 같이 응답하기 때문에

 

@JsonProperty를 이용해 필요한 정보만 필드만 매핑되도록 했다.

{
    "login": ,
    "id": ,
    "node_id": ,
    "avatar_url": ,
    "gravatar_id": "",
    "url": ,
    "html_url":,
    "followers_url": ,
    "following_url": ,
    "gists_url": ,
    "starred_url": ,
    "subscriptions_url": ,
    "organizations_url": ,
    "repos_url": ,
    "events_url": ,
    "received_events_url": ,
    "type": ,
    "site_admin": ,
    "name":,
    "company": ,
    "blog": ,
    "location":,
    "email": ,
    "hireable": ,
    "bio": ,
    "twitter_username": ,
    "public_repos": ,
    "public_gists": ,
    "followers": ,
    "following": ,
    "created_at": ,
    "updated_at":
}

 

TextParsingUtil

public class TextParsingUtil {

    public static Map<String, String> parsingFormData(String formData) {
        Map<String, String> map = new HashMap<>();
        String[] split = formData.split("&");
        for (String s : split) {
            String[] data = s.split("=");
            if (data.length >= 2) {
                map.put(data[0], data[1]);
            }
        }
        return map;
    }
    
}

Github에서 응답을

access_token={값}&expires_in={값}&refresh_token={값}&refresh_token_expires_in={값}&scope=&token_type={값}

위와 같이 하기 때문에, 위 형식을 Map 으로 Key- value 형식으로 저장하는 메서드를 정의했다.

 

 

 

이제 정의한 GithubJoinService 인터페이스의 구현체를 만들면서

 

RestTemplate · WebClient · FaignClient 이 3가지 방법을 다 사용해보도록 하겠다.

 

 

---

 

RestTemplate 방식

RestTemplate 는 Spring에서 지원하는 방식이고, 의존성을 따로 추가하지 않아도 사용할 수 있다.

 

REST API 호출 이후, 응답을 받을 때 까지 기다리는 동기 방식이다.

 

WebClient 방식이 추가되어 Deprecated 된 상태이지만, 한번 구현을 해보겠다.

 

RestTemplateConfig

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

 

빈으로 관리하기 위해 위와 같은 Config 클래스를 정의했다.

 

 

GithubJoinServiceRestTemplateImpl

@Service
@RequiredArgsConstructor
public class GithubJoinServiceRestTemplateImpl implements GithubJoinService {

    private final RestTemplate restTemplate;

    @Override
    public String getAccessToken(String clientId, String clientSecret, String code) {
        HttpEntity<String> response = restTemplate.exchange("https://github.com/login/oauth/access_token",
                HttpMethod.POST,
                setParam(clientId, clientSecret, code),
                String.class);

        return TextParsingUtil.parsingFormData(response.getBody()).get("access_token");
    }

    private HttpEntity<MultiValueMap<String, String>> setParam(String clientId, String clientSecret, String code) {
        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
        params.add("client_id", clientId);
        params.add("client_secret", clientSecret);
        params.add("code", code);
        return new HttpEntity<>(params, new HttpHeaders());
    }

    @Override
    public UserProfile getUserInfo(String accessToken) {

        UserProfile body = restTemplate.exchange("https://api.github.com/user"
                        , HttpMethod.GET
                        , setAccessToken(accessToken)
                        , UserProfile.class)
                .getBody();
        System.out.println("restTemplate " + body);
        return body;
    }

    private HttpEntity<MultiValueMap<String, String>> setAccessToken(String accessToken) {
        HttpHeaders requestHeaders = new HttpHeaders();
        requestHeaders.add("Authorization", String.format("Bearer %s",accessToken));
        return new HttpEntity<>(requestHeaders);
    }
}

전체 코드는 위와 같다.

 

RestTemplate 는 빈으로 등록되어 있어 주입될 것이다.

 

getAccessToken()

    @Override
    public String getAccessToken(String clientId, String clientSecret, String code) {
        HttpEntity<String> response = restTemplate.exchange("https://github.com/login/oauth/access_token",
                HttpMethod.POST,
                setParam(clientId, clientSecret, code),
                String.class);

        return TextParsingUtil.parsingFormData(response.getBody()).get("access_token");
    }

    private HttpEntity<MultiValueMap<String, String>> setParam(String clientId, String clientSecret, String code) {
        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
        params.add("client_id", clientId);
        params.add("client_secret", clientSecret);
        params.add("code", code);
        return new HttpEntity<>(params, new HttpHeaders());
    }

 

먼저 restemplate.exchange({url} , {HTTP Method} , {Request Body} , {응답받을 객체 타입}) 과 같은 형식으로 요청하면 된다.

 

그리고 response.getBody() 하면 위에서 설명했듯,

 

access_token={값}&expires_in={값}&refresh_token={값}&refresh_token_expires_in={값}&scope=&token_type={값}

 

위와 같은 문자열로 응답하므로, parsing해서 반환하면 된다.

 

getUserInfo()

    @Override
    public UserProfile getUserInfo(String accessToken) {

        return restTemplate.exchange("https://api.github.com/user",
                        HttpMethod.GET,
                        setAccessToken(accessToken),
                        UserProfile.class)
                .getBody();
    }

    private HttpEntity<MultiValueMap<String, String>> setAccessToken(String accessToken) {
        HttpHeaders requestHeaders = new HttpHeaders();
        requestHeaders.add("Authorization", String.format("Bearer %s",accessToken));
        return new HttpEntity<>(requestHeaders);
    }

 

이 부분도 유사하게 구현하면 된다.

 

다만, GET 요청을 해야하고 Authorization 헤더에 accessToken을 추가해주어야 한다.

 

참고 : https://docs.github.com/ko/rest/users/users?apiVersion=2022-11-28#get-the-authenticated-user

 

UserProfile은 이전에 설명했듯 구현하면, 자동 매핑되어 반환된다.

 

---

WebClient 방식

WebClient 는 동기 / 비동기 방식 HTTP 요청이 가능한, Spring 에서 권장하는 REST API 요청 방식이다.

 

Dependency 추가

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

위 의존성을 추가해준다.

 

WebClientConfig

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient webClient() {
        return WebClient.builder().build();
    }
}

 

AccessTokenRequest

@Getter
@Builder
public class AccessTokenRequest {
    @JsonProperty("client_id")
    private String clientId;
    @JsonProperty("client_secret")
    private String clientSecret;
    private String code;

    public static AccessTokenRequest createAccessTokenRequest(String clientId, String clientSecret, String code) {
        return AccessTokenRequest.builder()
                .clientId(clientId)
                .clientSecret(clientSecret)
                .code(code)
                .build();
    }
}

WebClient 방식은 Request Body 로 전달할 데이터를 객체로 정의해두고 

 

메서드 파라미터에 넣으면 직렬화시킬 수 있기 때문에 위와 같이 정의해둔다.

 

 

GithubJoinServiceWebClientImpl

@Service
@RequiredArgsConstructor
public class GithubJoinServiceWebClientImpl implements GithubJoinService {

    private final WebClient webClient;

    @Override
    public String getAccessToken(String clientId, String clientSecret, String code) {

        String response = webClient.post()
                .uri("https://github.com/login/oauth/access_token")
                .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .bodyValue(AccessTokenRequest.createAccessTokenRequest(clientId, clientSecret, code))
                .retrieve()
                .toEntity(String.class)
                .block()
                .getBody();


        return TextParsingUtil.parsingFormData(response).get("access_token");
    }

    @Override
    public UserProfile getUserInfo(String accessToken) {

        return webClient.get()
                .uri("https://api.github.com/user")
                .header("Authorization", String.format("Bearer %s",accessToken))
                .retrieve()
                .toEntity(UserProfile.class)
                .block()
                .getBody();

    }

}

 

전체 코드는 위와 같다.

 

getAccessToken()

    @Override
    public String getAccessToken(String clientId, String clientSecret, String code) {

        String response = webClient.post()
                .uri("https://github.com/login/oauth/access_token")
                .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
                .bodyValue(AccessTokenRequest.createAccessTokenRequest(clientId, clientSecret, code))
                .retrieve()
                .toEntity(String.class)
                .block()
                .getBody();

        return TextParsingUtil.parsingFormData(response).get("access_token");
    }

 

위와 같은 방식으로 구현하면 되고, post 요청 시, bodyValue() 메서드에 직렬화 시킬 객체를 넣어주면 된다.

 

getUserInfo()

    @Override
    public UserProfile getUserInfo(String accessToken) {

        return webClient.get()
                .uri("https://api.github.com/user")
                .header("Authorization", String.format("Bearer %s",accessToken))
                .retrieve()
                .toEntity(UserProfile.class)
                .block()
                .getBody();

    }

 

get 요청은 위와 같이 구현하면 되고, 

 

전달해야할 accessToken은 header("Authorization", "Bearer " + accessToken) 으로 전달하면 된다.

 

💡 확실히, 요청을 메서드 체인 방식으로 구현할 수 있어, RestTemplate 보다 코드 가독성이 좋다는 장점을 느낄 수 있었다.

 

---

FeignClient 방식

FeignClient는 Netflix에서 개발한 방식이라고 한다.

 

현재는 오픈소스로 전환되었으며 SpringCloud 프레임워크의 프로젝트 중 하나로 들어갔다고 한다.

 

테스트 코드를 짤 때 간편하고 가독성 높은 코드를 짤 수 있다고 한다.

 

단, 동기 요청만 가능하기 때문에 비동기 동작이 필요한 경우는 사용할 수 없다

 

 

Dependency 추가

implementation group: 'org.springframework.cloud', name: 'spring-cloud-starter-openfeign', version: '4.0.4'

Feign Client를 사용하기 위해 위 의존성을 추가해준다.

 

application.yml 추가

feign:
  client:
    access-token:
      url: https://github.com
    user-profile:
      url: https://api.github.com

테스트 코드 작성 시, url을 외부에서 주입할수 있게 환경변수로 등록해주면 좋다.

 

따라서 위와 같은 환경 변수를 추가해준다.

 

@EnableFeignClients 추가

@SpringBootApplication
@EnableFeignClients
public class GrowithApplication {

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

}

Application 실행하는 클래스에 @EnableFeignClients 를 추가한다.

 

AccessTokenFeignClient

@FeignClient(name = "access-token-feign-client", url = "${feign.client.access-token.url}")
public interface AccessTokenFeignClient {

    @PostMapping("/login/oauth/access_token")
    String getAccessToken(
            @RequestParam("client_id") String clientId,
            @RequestParam("client_secret") String clientSecret,
            @RequestParam("code") String code
    );
}

 

FeignClient 는 interface 형식으로 정의하여 REST API 요청을 할 수 있다.

 

Spring Data JPA 의 JpaRepository를 상속받아 사용하는 interface와 유사한 방식이라고 이해하면 된다.

 

accessToken을 응답받는 요청을 위해 위와 같이 정의했다.

 

정말 간단하게, 파라미터의 @RequestParam 을 통해 RequestBody의 body 를 설정할 수 있다.

 

UserProfileFeignClient

@FeignClient(name = "user-profile-feign-client", url = "${feign.client.user-profile.url}")
public interface UserProfileFeignClient {

    @GetMapping("/user")
    UserProfile getUserInfo(@RequestHeader("Authorization") String accessToken);
}

 

회원 정보를 받아오는 요청은 위와 같이 Header 에 Authorization을 추가해야하기 때문에 @RequestHeader 를 사용하면 된다.

 

Controller 코드 수정

@Controller
@RequiredArgsConstructor
public class UserJoinController {

    @Value("${github.client-id}")
    private String clientId;

    @Value("${github.client-secret}")
    private String clientSecret;

    private final UserJoinService userJoinService;

    private final AccessTokenFeignClient accessTokenFeignClient;
    
    private final UserProfileFeignClient userProfileFeignClient;

    @GetMapping("/oauth2/redirect")
    public String githubLogin(@RequestParam String code) {
        String response = accessTokenFeignClient.getAccessToken(clientId, clientSecret, code);

        return "redirect:/githubLogin/success?access_token=" + TextParsingUtil.parsingFormData(response).get("access_token");
    }

    @GetMapping("/githubLogin/success")
    public String githubLoginSuccess(HttpServletResponse response, @RequestParam(name = "access_token") String accessToken) {

        UserProfile userProfile = userProfileFeignClient.getUserInfo(String.format("Bearer %s",accessToken));

        String jwt = userJoinService.login(userProfile);

        CookieUtil.setCookie(response, JWT_COOKIE_NAME, jwt, JWT_COOKIE_AGE);

        return "redirect:/";
    }
}

 

accessTokenFeignClient.getAccessToken(clientId, clientSecret, code); 메서드의 응답 결과는

 

access_token={값}&expires_in={값}&refresh_token={값}&refresh_token_expires_in={값}&scope=&token_type={값}

 

와 같기 때문에, Controller 메서드에서 Parsing 작업을 해주도록 수정한다.

 

그리고, userProfileFeignClient.getUserInfo(String.format("Bearer %s",accessToken)); 이 부분 역시, Header 설정에 Bearer 키워드가 붙도록 수정해주면 된다.

 

---

Spring으로 REST API 요청을 할 수 있는 대표적인 방법들을 여러개를 모두 사용해보니

 

각 방식의 장단점을 알 수 있었다.

 

확실히 가장 오래된 기술인 RestTemplate 방식이, 요청을 구성하는 방식이 가장 불편했음을 알 수 있었다.

 

따라서, 비동기 요청이 필요한 경우에는 WebClient 를 사용할 것이고 동기 요청에는 FeignClient 를 사용하면 좋을 것 같다는 인사이트를 얻을 수 있었다.