YS's develop story

싱글톤 vs HikariCP, Connection 관리 부분에서 어떤 차이점이 있을까

Yusang — Thu, 1 May 2025 20:40:40 +0900

package util;

import io.github.cdimascio.dotenv.Dotenv;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    private static final Dotenv dotenv = Dotenv.load();
    private static final String URL = dotenv.get("DB_HOST");
    private static final String DB_USER = dotenv.get("DB_NAME");
    private static final String DB_PASSWORD = dotenv.get("DB_PW");

    // DB 연결 메서드
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, DB_USER, DB_PASSWORD);
    }
}

public class LendingBookDao {

    public int insertLending(Long bookId, Long userId, LocalDateTime dueDate) {
        String sql = LendingBookSql.INSERT;

        try (Connection connection = DBUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {

            preparedStatement.setLong(1, bookId);
            preparedStatement.setLong(2, userId);
            preparedStatement.setTimestamp(3, Timestamp.valueOf(dueDate));
            preparedStatement.setInt(4, LendingStatus.IS_BORROWED);

            //영향을 받은 행의 갯수를 출력하게 된다.
            return preparedStatement.executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
            return ResultCode.IS_ERROR;
        }
    }
 }

싱글톤, HikariCp을 모두 적용하지 않은 순수 JDBC 코드

✅ 커넥션 관리: 싱글톤 vs HikariCP 차이점

JDBC만을 활용하는 프로젝트를 진행하다가, 매번 DB와 연결하는 Connection 부분을 싱글톤 패턴으로 바꾸려고 하던 중,
예전에 사용했던 Hikari 커넥션 풀이 떠올라 둘의 차이를 비교해 보기 위해 이 글을 작성하게 되었습니다.

DB 커넥션 관리는 왜 중요한가?

DB 연결을 매번 새로 만드는 것은 성능에 매우 안 좋습니다.
DB 연결(Connection)은 리소스를 많이 소모하는 작업이기 때문에,
매번 새로 만들기보다는 재사용 가능한 커넥션 풀(Connection Pool)을 활용하는 것이 효율적입니다.

HikariCP 적용 전후 코드

적용 전 (DB 커넥션)

package util;

import io.github.cdimascio.dotenv.Dotenv;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    private static final Dotenv dotenv = Dotenv.load();
    private static final String URL = dotenv.get("DB_HOST");
    private static final String DB_USER = dotenv.get("DB_NAME");
    private static final String DB_PASSWORD = dotenv.get("DB_PW");

    // DB 연결 메서드
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, DB_USER, DB_PASSWORD);
    }
}

싱글톤 적용 (DB 커넥션)

package util;

import io.github.cdimascio.dotenv.Dotenv;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {
    private static final DBUtil instance = new DBUtil();

    private final String URL;
    private final String DB_USER;
    private final String DB_PASSWORD;

    // private 생성자
    private DBUtil() {
        Dotenv dotenv = Dotenv.load();
        this.URL = dotenv.get("DB_HOST");
        this.DB_USER = dotenv.get("DB_NAME");
        this.DB_PASSWORD = dotenv.get("DB_PW");
    }

    // 인스턴스를 반환하는 메서드
    public static DBUtil getInstance() {
        return instance;
    }

    // DB 연결 메서드
    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, DB_USER, DB_PASSWORD);
    }
}

HikariCP 커넥션 풀 적용 후

package util;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import io.github.cdimascio.dotenv.Dotenv;

import java.sql.Connection;
import java.sql.SQLException;

public class DBUtil {

    private static final HikariDataSource dataSource;
    private static final Dotenv dotenv = Dotenv.load();

    // HikariCP 설정
    static {
        // Dotenv 라이브러리로 환경 변수 로드
        Dotenv dotenv = Dotenv.load();

        // HikariCP 설정
        HikariConfig config = new HikariConfig();

        // .env 파일에서 DB 연결 정보 가져오기
        config.setJdbcUrl(dotenv.get("DB_HOST"));
        config.setUsername(dotenv.get("DB_NAME"));
        config.setPassword(dotenv.get("DB_PW"));

        // 커넥션 풀 사이즈 설정
        config.setMaximumPoolSize(10);

        // 설정된 데이터소스를 이용하여 커넥션 풀 초기화
        dataSource = new HikariDataSource(config);
    }

    // DB 연결 메서드
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

커넥션 풀의 개념과 장점

커넥션 풀(Connection Pool)은 미리 여러 개의 DB 연결을 만들어 두고,
필요할 때마다 꺼내서 쓰고 다시 돌려주는 방식입니다.

커넥션 풀을 사용하면?

✅ 커넥션 생성 비용 최소화
✅ 연결/해제 과정을 줄여 성능 향상
✅ 멀티스레드 환경에 안전
✅ 설정에 따라 유휴 연결, 타임아웃 등 관리 가능

싱글톤 방식 vs HikariCP 비교

✅ 1. 싱글톤 패턴으로 Connection 관리

설명:

싱글톤은 애플리케이션 전체에서 단 하나의 Connection 객체만 사용하도록 만드는 방식입니다.

장점:

구현이 매우 간단함.
메모리 낭비를 막고, 단일 객체를 통해 일관된 DB 접근 가능.

단점:

DB 연결을 계속 유지하므로, 연결이 끊기거나 유휴 상태가 오래되면 장애 가능성이 큼.
멀티스레드 환경에 부적합: 여러 요청이 하나의 Connection을 공유하면 동시 처리 시 충돌 발생.
트랜잭션 분리가 어려움.

적합한 상황:

단일 사용자 / 테스트 환경 / 간단한 애플리케이션.

✅ 2. HikariCP (Connection Pool)

설명:

HikariCP는 JDBC 연결을 미리 여러 개 만들어 놓고, 요청마다 풀에서 빌려 쓰고 반납하는 방식입니다.

장점:

고성능, 경량 커넥션 풀: 현재 가장 빠르고 널리 사용됨.
스레드 세이프: 다중 사용자 환경에 적합.
풀링 된 커넥션 재사용 → 커넥션 생성/종료 오버헤드 감소.
연결 유휴 시간, 타임아웃, 최대 수 제한 등 다양한 설정 가능.

단점:

설정이 약간 복잡할 수 있음.
메모리를 약간 더 사용함 (여러 커넥션 유지하므로).

적합한 상황:

웹 애플리케이션, 동시 접속이 많은 서비스, 프로덕션 환경.

✅ 결론

테스트 용도나 학습 목적이라면 싱글톤으로도 충분합니다.
하지만, 실제 운영 환경이라면 반드시 HikariCP 같은 커넥션 풀 라이브러리 사용을 권장합니다.
특히 Spring Boot와 같이 프레임워크에서 기본 지원하기 때문에 설정만 해주면 쉽게 사용할 수 있습니다.

참고

Spring Boot + Redis 캐시 적용 가이드 (@Cacheable 활용)

Yusang — Thu, 30 May 2024 15:24:47 +0900

@SpringBootApplication
@EnableJpaAuditing
@EnableCaching //캐싱 기능을 활성화 하겠다는 어노테이션 -> redis활용을 위해 추가
public class SpringJavaApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringJavaApplication.class, args);
    }

}

@EnableCaching 어노테이션 추가

캐싱 기능을 활성화하겠다는 어노테이션입니다.

//redis
implementation 'org.springframework.boot:spring-boot-starter-data-redis'

@Cacheable

메서드에 붙여서 사용할 것을 권장하고, 캐시를 저장 또는 조회할 때 사용 합니다.

메서드에서 조회할 캐시 데이터가 캐시 서버에 있는지 확인하고, 있으면 반환하고 없으면 새로 저장한 후 반환

@CachePut

메서드에 붙여서 사용할 것을 권장하고, 캐시를 저장 또는 수정하는 목적으로만 사용합니다.

즉, 메서드에서 조회하고자 하는 데이터는 DB에서 직접 꺼내서 전달하고, 그 결과를 캐시 서버에 반영하기만 함

@CacheEvict

캐시 제거를 위해서 사용합니다.

역시 메서드에 붙여서 사용하는 것이 바람직하고, 삭제 기능을 갖고 있는 메서드에 붙여서 사용할 수 있습니다.

Redis를 이용해 JWT 활용하기 (Refresh Token 저장 시 Redis활용)

Yusang — Thu, 30 May 2024 14:51:23 +0900

test-redis:
  container_name: test-redis
  image: redis:6
  hostname: redis
  command: redis-server --port 6379
  ports:
    - "6379:6379"
  volumes:
    - ./redis/data:/data
  environment:
    - TZ=Asia/Seoul
  labels:
    - "name=redis"
    - "mode=standalone"
  restart: always

Docker 위에서 Redis를 올려놓고 사용할 것이기 때문에 docker-compose.yml 파일 수정

spring:
  config:
    activate:
      on-profile: dev

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3307/test?characterEncoding=UTF-8
    username: root
    password: root

  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.MySQLDialect

  data:
    redis:
      host: localhost
      port: 6379

application.yml 파일에 Redis 설정 추가

//redis config 설정 클래스들
@Configuration
public class RedisConfig {

    @Bean
    LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory());
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .entryTtl(Duration.ofMinutes(10L)); // 캐시의 TTL 설정 (10분)

        return RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(factory)
                .cacheDefaults(cacheConfig)
                .build();
    }

    //Redis는 LocalDateTime과 같은 일부 타입을 직렬화할 수 없기 때문에
    //Redis의 직렬화 도구인 GenericJackson2JsonRedisSerializer를 구성하여 Java 8의 시간 관련 타입을 처리할 수 있도록 함.
    @Bean
    public RedisSerializer<Object> redisSerializer() {
        return new GenericJackson2JsonRedisSerializer(new ObjectMapper().registerModule(new JavaTimeModule()));
    }
}

Redis config 설정

클라이언트가 로그인을 성공하면, 서버는 Access Token과 Refresh Token을 함께 제공합니다.
이후 클라이언트는 인가가 필요한 요청에 Access Token을 header에 담아서 요청하게 됩니다.
시간이 조금 흘러 Access Token이 만료되었다면, 클라이언트는 Refresh Token을 서버로 전달하여 새로운 Access Token을 발급받습니다.

여기서 Refresh Token 토큰을 DB에 저장하지 않고 Redis에 저장하는 방식을 구현해보고자 했습니다.

이렇게 했을 때의 장점은 Redis는 메모리 내 데이터 구조 저장소로서 매우 빠른 응답 시간을 제공하는데,

그렇기에 인증 서버에서 자주 액세스하는 데이터를 Redis에 저장하면 DB 액세스보다 더 빠른 응답 시간을 얻을 수 있습니다.

Refresh Token은 인증 서버에 자주 요청되는 데이터 중 하나이므로,

이를 Redis에 저장함으로써 전반적인 성능을 향상할 수 있습니다.

//redis
implementation 'org.springframework.boot:spring-boot-starter-data-redis'

//Redis는 LocalDateTime과 같은 일부 타입을 직렬화할 수 없기 때문에
//Redis의 직렬화 도구인 GenericJackson2JsonRedisSerializer를 구성하여 Java 8의 시간 관련 타입을 처리할 수 있도록 함.
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'

Redis 관련 gradle 추가

@Getter
@RedisHash(value = "refreshToken", timeToLive = 60 * 60 * 2)
//titmeToLive -> 만료시간 설정 초 단위
//timeToLive의 시간이 지나면 redis에 저장된 RefreshToken이 만료 됨

public class RefreshToken {

    //java.persistence.id가 아닌 opg.springframework.data.annotation.Id 를 import해야 함
    //Refresh Token은 Redis에 저장하기 때문에 JPA 의존성이 필요하지 않음. persistence로 하게되면 에러 발생
    @Id
    private String refreshToken;
    private Long userId;

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

    //역직렬화를 위한 기본 생성자
    public RefreshToken() {
    }
}

RefreshToken class 생성

이때 java.persistence.id가 아닌 opg.springframework.data.annotation.Id 를 import 해야 합니다.
여기서 Refresh Token은 DB에 저장하는 것이 아닌 Redis에 저장하기 때문에 JPA 의존성이 필요하지 않습니다. -> persistence로 하게 되면 에러가 발생합니다.

public interface RefreshTokenRepository extends CrudRepository<RefreshToken, String> {

    @Override
    Optional<RefreshToken> findById(String s);
}

RefreshToken CrudRepository 생성

public String createRefreshToken(User user, RefreshTokenRepository refreshTokenRepository) {
    String refreshToken = UUID.randomUUID().toString();
    RefreshToken redisRefreshToken = RefreshToken.builder().
            refreshToken(refreshToken).
            userId(user.getId()).
            build();

    refreshTokenRepository.save(redisRefreshToken);

    return refreshToken;
}

jwtProvider에 RefreshToken을 생성하는 함수 createRefreshToken을 생성

이때 Refresh Token은 UUID을 통해서 생성

@Override
protected void successfulAuthentication(
        HttpServletRequest request,
        HttpServletResponse response,
        FilterChain chain,
        Authentication authResult
) throws IOException {
    User user = ((PrincipalDetails) authResult.getPrincipal()).getUser();
    String token = jwtProvider.createToken(user);
    String refreshToken = jwtProvider.createRefreshToken(user, refreshTokenRepository);

    LoginResponseDTO loginResponseDto = LoginResponseDTO.fromEntity(user, token, refreshToken);
    ResponseDTO<LoginResponseDTO> loginResponse = ResponseDTO.okWithData(loginResponseDto);

    sendJsonResponse(response, loginResponse, HttpStatus.OK);
}

로그인 성공 시 Access Token과 Refresh Token을 생성하여 보낼 수 있도록 코드 작성

이후 확인을 하면 로그인 시 Access Token과 Refresh Token을 모두 발급하고 successfulAuthentication에서 작성한 대로 Refresh Token은 Redis에 저장되고 있습니다.

Refresh Token의 만료시간은 Refresh Token 클래스의 TTL 시간이고 이 시간이 지나게 되면 redis에 저장된 값이 사라지기 때문에 Refresh Token이 만료되게 됩니다.

클라이언트는 로그인 성공 시 짧은 만료시간을 가진 Access Token과 약간 긴 만료시간을 가진 Refresh Token을 발급받게 되는데, 시간이 흘러 Access Token이 만료된다면 서버로 Refresh Token을 보내서 Access Token을 재발급받을 수 있습니다.

Access Token이 짧은 만료시간을 갖게 되는 건 Access Token이 탈취될 수 있기 때문에

토큰의 만료시간을 짧게 하는 보안성의 이점이 있다고 할 수 있습니다.

그렇다면 이제 redis에 Refresh Token이 존재한다면 서버에서 올바른 Refresh Token을 받았을 때,

해당 유저의 Access Token을 재 발급하는 코드를 작성해야 합니다.

@RequiredArgsConstructor
@RestController
public class TokenController {

    private final TokenService tokenService;

    @PostMapping("/access-token")
    public ResponseEntity<ResponseDTO<GetNewAccessTokenResponseDTO>>
    getNewAccessToken(@RequestBody RefreshToken refreshToken) {

        GetNewAccessTokenResponseDTO getNewAccessTokenResponseDTO =
                tokenService.generateAccessToken(refreshToken);

        ResponseDTO<GetNewAccessTokenResponseDTO> response
                = ResponseDTO.okWithData(getNewAccessTokenResponseDTO);

        return ResponseEntity
                .status(response.getCode())
                .body(response);
    }
}

Token controller


@RequiredArgsConstructor
@Transactional
@Service
public class TokenService {

    private final RefreshTokenRepository refreshTokenRepository;
    private final UserRepository userRepository;
    private final JwtProvider jwtProvider;

    public GetNewAccessTokenResponseDTO generateAccessToken(final RefreshToken refreshToken) {

        //redis의 refresh token의 유효기간이 지나지 않았는지
        RefreshToken refreshTokenCheck = refreshTokenRepository.findById(refreshToken.getRefreshToken())
                .orElseThrow(ExpiredRefreshTokenException::new);

        User user = userRepository.findById(refreshTokenCheck.getUserId())
                .orElseThrow(UserNotFoundException::new);

        return GetNewAccessTokenResponseDTO.fromEntity(jwtProvider.createToken(user));
    }
}

TokenService

Redis에 Refresh Token이 존재하는지 체크하고, 존재한다면 저장된 userId를 기반으로 jwt토큰을 재발급합니다.

public record GetNewAccessTokenResponseDTO(
        String token
) {

    public static GetNewAccessTokenResponseDTO fromEntity(String token) {
        return new GetNewAccessTokenResponseDTO(
                token
        );
    }
}

GetNewTokenResponseDTO

POST /access-token

을 통해서 Access Token을 성공적으로 재발급받을 수 있습니다.

야놀자테크스쿨 미니프로젝트 정리 및 회고

Yusang — Fri, 22 Dec 2023 18:57:24 +0900

⭐패키지 구조

 com.example.yanolja  
 ├── domain  
 │   ├── user  
 │   ├── accommodation  
 │   ├── review  
 │   ├── reservation  
 │   ├── accommodationLikes  
 │   ├── basket  
 │   ├── wishlist  
 │   ...  
 └── global  
      ├── springsecurity  
      ├── entity  
      ├── config  
      ├── exception  
      ├── jwt  
      └── util

⭐ERD

⭐ FlowChart

⭐Project Architecture

⭐담당 역할

spring security
프로젝트 배포
장바구니, 결제
사용자 예약조회
메인페이지
로그인(OAuth2)
Querydsl

⭐ 프로젝트 구현 내용과 관련하여 작성한 블로그 글정리

프로젝트 진행하면서 생겼었던 문제들을 그때그때 기록하고 정리해 놨었습니다.

아래 글들은 해당 프로젝트를 진행하면서 사용했었던 기술들을 기록하고자 블로그에 작성했었던 글들입니다.

Spring, Docker에서 MySQL 데이터베이스 컨테이너 설정하기

docker-compose.yml 설정 파일 version: '3' services: travel-db: container_name: test build: context: ./database dockerfile: Dockerfile ports: - "3307:3306" restart: always healthcheck: test: [ "CMD", "mysqladmin" ,"ping", "-h", "localhost" ] timeout: 30

yusang.tistory.com

GCP 에서 springboot 프로젝트 docker로 배포하기

GCP로 이동합니다. Google 클라우드 플랫폼 로그인 Google 클라우드 플랫폼으로 이동 accounts.google.com vm인스턴스 -> 인스턴스 생성 아래와 같이 설정했습니다. 가장 저렴한 비용으로 할 수 있습니다. OS

yusang.tistory.com

springboot certbot으로 ssl인증서 받아서 https로 배포하기

ssl 인증서를 받기 위해서는 등록할 도메인이 필요합니다. 그래서 저는 가비아에서 1900짜리 제일 싼 도메인을 1년 구매했습니다. 그리고 배포한 인스턴스의 주소를 등록해 주었습니다. https://certb

yusang.tistory.com

spring jpa에 Querydsl 적용하기 [spring 3.1.5, java 17]

개발하고 있는 프로젝트에 Querydsl을 적용해 보려고 합니다. Querydsl의 장점 유연성 및 강력한 검색 기능 : Query DSL을 사용하면 복잡한 검색 조건을 표현할 수 있습니다. 진행하고 있는 프로젝트 메

yusang.tistory.com

Spring, OAuth2 + JWT 를 활용하여 소셜 로그인 구현하기 1편 (구글 및 네이버) [Spring 3.1.5, java 17]

글 작성하기에 앞서 ppt로 정리한 전체적인 동작 흐름입니다. 현재 제 프로젝트에서는 아래와 같이 OAuth를 통한 구글, 네이버 로그인을 구현했고 그 과정을 정리하려고 글을 작성하게 되었습니다

yusang.tistory.com

Spring, OAuth2 + JWT 를 활용하여 소셜 로그인 구현하기 2편 (구글 및 네이버) [Spring 3.1.5, java 17]

이 글은 전글과 이어집니다.! https://yusang.tistory.com/140 Spring, OAuth2 + JWT 를 활용하여 구글 소셜 로그인 구현하기 [Spring 3.1.5, java 17] http://console.cloud.google.com/project Google 클라우드 플랫폼 로그인 Google

yusang.tistory.com

⭐시연영상

⭐배포페이지

https://dashing-tiramisu-cbdade.netlify.app

⭐회고

❗ 짧은 기간 동안 빠르게 기능구현을 위주로 개발을 하려고 하다 보니 다시 돌아와서 코드를 보았을 때 로직이 복잡하고 좋지 않은 코드들이 많이 보였던 거 같습니다. 다음에 비즈니스 로직을 구현할 때 있어서 좀 더 생각을 하고 좋은 설계를 바탕으로 코드를 짜면 더 좋을 거 같습니다. 이번경험을 바탕으로 코드작성에 있어서 더 생각을 해 볼 수 있을 거 같습니다. 좋은 경험이었습니다.

❗ 도커 위에서 작업을 하고, 도커이미지를 통해 배포를 해보았는데 이 경험이 매우 좋았습니다. 도커이미지로 배포를 했기 때문에 배포환경에 구애받지 않고 필요한 프로그램들 설치 없이 언제 어디서든 똑같은 배포환경을 유지할 수 있다는 점이 매우 편리했습니다.
이 과정은 기존 jar로 배포하던 것보다 훨씬 간편했던 거 같고 유용한 기술이었습니다.
Docker에 대해 좀 더 공부해 보고 더 다양한 기술들을 써보고 싶은 계기가 되었던 거 같습니다.

❗ querydsl을 활용해 메인페이지 JPQL을 개선했으며 OAuth2 client를 활용해 소셜로그인을 구현해 본 것,
redis를 활용한 캐시 DB를 추후 리팩토링 시간에 추가적으로 적용해 볼 수 있어서 좋았던 것 같습니다.

❗ 처음 써보는 새로운 기술들을 적용하면서 여러 가지 문제점이 있었지만 팀원들과 같이 의논하고 같이 개발하면서 문제를 해결했었던 것 같습니다. 덕분에 실력이 많이 늘어서 좋았습니다.

Spring, OAuth2 + JWT 를 활용하여 소셜 로그인 구현하기 2편 (구글 및 네이버) [Spring 3.1.5, java 17]

Yusang — Mon, 11 Dec 2023 22:01:24 +0900

이 글은 전글과 이어집니다.!

https://yusang.tistory.com/140

Spring, OAuth2 + JWT 를 활용하여 구글 소셜 로그인 구현하기 [Spring 3.1.5, java 17]

http://console.cloud.google.com/project Google 클라우드 플랫폼 로그인 Google 클라우드 플랫폼으로 이동 accounts.google.com 프로젝트 만들기 -> API 및 서비스 -> 사용자 인증정보 -> 사용자 인증 정보 만들기 -> OAu

yusang.tistory.com

과정 설명에 앞서서 전체적인 동작방식을 ppt로 만들어 보았습니다.

전체적인 동작 방식을 그림으로 정리하자면 아래와 같습니다.

네이버 개발자 사이트에 접속합니다.

그 후 아래와 같이 애플리케이션 등록을 합니다.

이때 네이버로그인 시 제공받을 정보를 선택합니다.

참고로 저는 ssl인증서를 받아서 등록했기에 https로 요청을 했습니다

등록 후 발급받은 id와 key를 기억해야 합니다.

아래의 네이버 로그인 개발가이드 공식문서를 참고하여 yml 파일에 코드를 추가합시다.

네이버 로그인 개발가이드 - LOGIN

네이버 로그인 개발가이드 1. 개요 4,200만 네이버 회원을 여러분의 사용자로! 네이버 회원이라면, 여러분의 사이트를 간편하게 이용할 수 있습니다. 전 국민 모두가 가지고 있는 네이버 아이디

developers.naver.com

네이버 소셜 로그인은 OAuth2.0 공식 지원 대상이 아니기에 provider가 기본적으로 제공되고 있지 않습니다.

그렇기에 provider 설정이 필요하고, google로그인과 달리 직접 지정해야 하는 값들이 있습니다.

전편에서 추가했었던 google 아래에 naver를 아래와 같이 추가해 줍니다.

이때 들여 쓰기에 유의해야 합니다.

IDE에서 인식해야 합니다.

security:
  oauth2:
    client:
      registration:
        google:
          client-id: ${GOOGLE_ID}
          client-secret: ${GOOGLE_KEY}
          scope:
            - email
            - profile

        naver:
          client-id: key
          client-secret: value
          scope:
            - name
            - email
          client-name: Naver
          authorization-grant-type: authorization_code
          redirect-uri: https://localhost:8080/login/oauth2/code/naver


      provider:
        naver:
          authorization-uri: https://nid.naver.com/oauth2.0/authorize
          token-uri: https://nid.naver.com/oauth2.0/token
          user-info-uri: https://openapi.naver.com/v1/nid/me
          user-name-attribute: response

구글 로그인때와 마찬가지로 아래에 엔드포인트로 보내면

네이버 로그인이 나오게 됩니다.

http://localhost:8080/oauth2/authorization/naver

그 후 System.out으로 정보를 출력하면 아래와 같이 로그인정보가 출력됩니다.

getAttributes: {resultcode=00, 
message=success, 
response={id=nsTFmLViERwRxCE_M03ep0uk6qXv148cUp9ppSQWpsk, 
email=개인정보, 
mobile=개인정보, 
mobile_e164=+개인정보,
name=이유상}}

이때 로그인 페이지에서 로그인을 수행하고,

승인하면 Spring Security가 제공한 콜백 엔드포인트로 다시 리다이렉트 됩니다.

여기서는 아까 설정 한 http://localhost:8080/login/oauth2/code/naver로 리다이렉트 됩니다.

배포된 환경에서 OAuth 로그인을 하려고 한다면

배포된 도메인도 같이 네이버 로그인 애플리케이션을 등록할 때 같이 입력해야지

배포환경에서도 OAuth 로그인을 할 수 있습니다.

승인된 리디렉션 URI를 등록하지 않는다면

400 오류 redirect_uri_mismatch 에러가 발생하게 됩니다.

저번 포스팅에 google 소셜 로그인을 추가한 상황에서 naver 소셜 로그인을 추가하고자 했기 때문에

구글 로그인인지, naver로그인인지에 따라 상황을 분기하여야 합니다.

따라서 아래처럼 코드를 수정해 줍니다.

우리는 userRequest.getClientRegistration().getRegistrationId()를 통해서

google 로그인인지, naver 로그인인지 알 수 있습니다.

또한 OAuth2UserInfo interface을 생성하여

OAuth2.0 제공자들마다 응답해 주는 공통의 속성을 만들어 줍니다.

그리고 그 후 이를 implement 한 NaverUserInfo, GoogleUserInfo을 각각 생성해 줍니다.

그렇게 되면 아래와 같이 상황에 따라 맞는 정보를 생성하고 처리를 할 수 있습니다.

@Service
@RequiredArgsConstructor
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    private final UserRepository userRepository;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {

        //System.out.println("getClientRegistration: " + userRequest.getClientRegistration());
        //System.out.println("getAccessToken: " + userRequest.getAccessToken());
        //System.out.println("getAttributes: " + super.loadUser(userRequest).getAttributes());

        OAuth2User oauth2User = super.loadUser(userRequest);

        OAuth2UserInfo oauth2Userinfo = null;
        String provider = userRequest.getClientRegistration().getRegistrationId(); //google kakao facebook...

        if(provider.equals("google")){
            oauth2Userinfo = new GoogleUserInfo(oauth2User.getAttributes());
        } else if(provider.equals("naver")){
            oauth2Userinfo = new NaverUserInfo((Map)oauth2User.getAttributes().get("response"));
        }

        Optional<User> user = userRepository.findByEmailAndProvider(
            oauth2Userinfo.getEmail(),oauth2Userinfo.getProvider());

        //이미 소셜로그인을 한적이 있는지 없는지
        if (user.isEmpty()) {
            User newUser = User.builder()
                .email(oauth2Userinfo.getEmail())
                .username(oauth2Userinfo.getName())
                .password("OAuth2")  //Oauth2로 로그인을 해서 패스워드는 의미없음.
                .phonenumber(oauth2Userinfo.getPhoneNumber())
                .authority("ROLE_USER")
                .provider(provider)
                .build();

            userRepository.save(newUser);
            return new PrincipalDetails(newUser, oauth2User.getAttributes());
        } else {
            return new PrincipalDetails(user.get(), oauth2User.getAttributes());
        }
    }
}

public interface OAuth2UserInfo {
    String getProviderId();
    String getProvider();
    String getEmail();
    String getName();
    String getPhoneNumber();
}

public class NaverUserInfo implements OAuth2UserInfo {

    private Map<String, Object> attributes;

    public NaverUserInfo(Map<String, Object> attributes) {
        this.attributes = attributes;
    }

    @Override
    public String getProviderId() {
        return (String) attributes.get("id");
    }

    @Override
    public String getName() {
        return (String) attributes.get("name");
    }

    @Override
    public String getPhoneNumber() {
        return (String) attributes.get("mobile");
    }

    @Override
    public String getEmail() {
        return (String) attributes.get("email");
    }

    @Override
    public String getProvider() {
        return "naver";
    }
}

public class GoogleUserInfo implements OAuth2UserInfo{

    private Map<String, Object> attributes;

    public GoogleUserInfo(Map<String, Object> attributes) {
        this.attributes = attributes;
    }

    @Override
    public String getProviderId() {
        return (String) attributes.get("sub");
    }

    @Override
    public String getName() {
        return (String) attributes.get("name");
    }

    @Override
    public String getPhoneNumber() {
        return null;
    }

    @Override
    public String getEmail() {
        return (String) attributes.get("email");
    }

    @Override
    public String getProvider() {
        return "google";
    }
}

이제 아래 엔드포인트로 네이버 로그인을 요청해 봅시다.

localhost:8080/oauth2/authorization/naver

로그인 성공 시 발급받은 JWT를 확인할 수 있습니다.

JWT을 통한 사용자 인증도 잘되네요.

네이버 로그인을 서비스에서 제대로 사용하고자 한다면

네이버 검수요청을 진행해서 받아야 합니다.

그전까지는 멤버관리에서 등록한 아이디만 등록할 수 있습니다.

그래서 현재 네이버 로그인 과정을 정확히 캡처하여 검수 요청을 했습니다.!

또한 주의해야 할 점이 로컬에서 테스트 후

배포 시에는 OAuth2로 네이버 로그인을 할 경우

redirect-uri를 배포 주소로 변경해야 합니다!

이후 업데이트

OAuth2LoginSuccessHandler를 다음과 같이 변경하여 프론트단으로 JWT토큰을 쿼리스트링에 담아

리디렉트 되도록 하고 로그인 처리를 하도록 변경했습니다.

이유는 이렇게 발급한 JWT토큰은 프론트단에서 추출하여 사용을 하지 못하기 때문입니다.

@Component
@RequiredArgsConstructor
public class OAuth2LoginSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    private final JwtProvider jwtProvider;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication authentication) throws IOException, ServletException {

        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
        String token = jwtProvider.createToken(principalDetails.getUser());
        String email = principalDetails.getEmail();
        String name = principalDetails.getUsername();

        //코드 내로 리디렉트 설정
        //String redirectUrl = "/user/oauth-success?token="+token;

        //한국어 인코딩 설정
        String encodedName = URLEncoder.encode(name, StandardCharsets.UTF_8.toString());
        
        String redirectUrl = "프론트도메인?token=" + token
        +"&email="+email+"&name="+encodedName;
        
        getRedirectStrategy().sendRedirect(request, response, redirectUrl);
    }
}

callback url에 프론트 도메인을 추가하여 줍니다.

프론트단으로 리디렉트 돼서 로그인을 처리할 것이기 때문입니다.

로그인 화면에서 네이버로 시작하기를 클릭 후

로그인 창이 뜨면 로그인을 하면

최초 로그인시 정보 제공을 동의하는지 나옵니다.

동의하면 정보가 제공되어 DB에 정보가 저장되게 됩니다.

그 후 로그인 처리가 되어 메인페이지로 온 것을 볼 수 있습니다.

내 정보 조회를 하면 네이버 OAuth로 로그인한 정보가 확인 가능하네요.

전체적인 과정을 정리하면 아래 이미지와 같습니다.

Spring, OAuth2 + JWT 를 활용하여 소셜 로그인 구현하기 1편 (구글 및 네이버) [Spring 3.1.5, java 17]

Yusang — Fri, 8 Dec 2023 07:26:01 +0900

글 작성하기에 앞서 ppt로 정리한 전체적인 동작 흐름입니다.

현재 제 프로젝트에서는 아래와 같이 OAuth를 통한 구글, 네이버 로그인을 구현했고

그 과정을 정리하려고 글을 작성하게 되었습니다.

http://console.cloud.google.com/project

Google 클라우드 플랫폼

로그인 Google 클라우드 플랫폼으로 이동

accounts.google.com

프로젝트 만들기 -> API 및 서비스 -> 사용자 인증정보 -> 사용자 인증 정보 만들기 -> OAuth 클라이언트 ID

승인할 리디렉션 URI를 설정 후

생성 후 사용자 인증 정보에서 클라이언트 ID 및 클라이언트 보안 비밀번호 확인 가능

이것을 복사해 놓습니다.

gradle에 추가

dependencies {
    //oauth
    implementation("org.springframework.boot:spring-boot-starter-oauth2-client")
}

들여 쓰기 유이하여 yml파일에 아래와 같이 코드 작성

  security:
    oauth2:
      client:
        registration:
          google:
            client-id: 발급받은 id
            client-secret: 발급받은 비밀번호
            scope:
              - email
              - profile

securityConfig에 추가

여기서 OAuth 로그인 후 후처리는 principalOauth2UserService 여기서 진행하게 됩니다.

  http
           .oauth2Login((oauth2) -> oauth2
            .userInfoEndpoint(userInfoEndpoint -> userInfoEndpoint
                .userService(principalOauth2UserService))
            .defaultSuccessUrl("/", true));

DefaultOauth2 UserService을 상속받은 principalOauth2UserService 클래스를 만들고,

구글 로그인 후 값을 잘 가져오는지 콘솔로 찍어 확인해 보려고 합니다.

@Service
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {

        System.out.println("getClientRegistration: "+userRequest.getClientRegistration());
        System.out.println("getAccessToken: "+userRequest.getAccessToken());
        System.out.println("getAttributes: "+super.loadUser(userRequest).getAttributes());

        return super.loadUser(userRequest);
    }
}

http://localhost:8080/oauth2/authorization/google

위 같은 엔드 포인트로 요청을 보내면 구글 로그인을 할 수 있습니다.

그런데 따로 엔드포인트를 설정한게 없는데 어떻게 아래 엔드포인트로 Oauth 로그인이 될까요?

Spring Security OAuth2의 기본 동작 중 하나는 각 OAuth2 제공자에

대한 로그인 엔드포인트를 자동으로 생성하는 것입니다.

그렇기 때문에 사용자가 해당 엔드포인트로 이동하면 OAuth2 로그인 프로세스가 시작됩니다.

사용자는 해당 제공자의 로그인 페이지에서 로그인을 수행하고,

승인하면 Spring Security가 제공한 콜백 엔드포인트로 다시 리다이렉트 됩니다.

Google의 경우 /login/oauth2/code/google로 리다이렉트 됩니다.

그래서 위에서 승인된 리디렉션 URI로

localhost:8080/login/oauth2/code/google 을 입력한 것입니다.

그렇기에 배포된 환경에서 OAuth 로그인을 하려고 한다면

배포된 도메인도 같이 입력해야지 배포환경에서도 OAuth 로그인을 할 수 있습니다.

실제로 승인된 리디렉션 URI를 등록하지 않는다면

아래와 같이 400 오류 redirect_uri_mismatch 에러가 발생하게 됩니다.

그리고 구글 로그인을 진행해 줍니다.

그러면 아래와 같이 콘솔에 출력되는 로그인 정보들을 확인할 수 있습니다.

이를 자세히 보면 구글로그인을 통해 가져온 정보들임을 알 수 있습니다.

이제 이렇게 가져온 정보들을 통해 로그인을 하고 DB에 저장하여 user로 생성해야 할 것입니다.

getAccessToken: org.springframework.security.oauth2.core.OAuth2AccessToken@171dce06
getAttributes: {sub=109646515849671741701, 
name=이유상, 
given_name=이유상, 
picture=https://lh3.googleusercontent.com/a/ACg8ocIDIAJdY7rkevOPxHTNSErvDt_nHubf3Omnk83p6DW38FM=s96-c, 
email=liyusang799@gmail.com, 
email_verified=true, 
locale=ko}

스프링 시큐리티 세션에 들어갈 수 있는 타입은 Authentication 객체 밖에 없습니다.

Authentication객체 안에 들어갈 수 있는 두 개의 타입은 UserDetails (일반적인 로그인),

Oauth2 User(Oauth를 통한 로그인.. 소셜 로그인)입니다.

controller에서 로그인 상태를 확인할 때 oauth2를 통해 로그인을 한 경우와

일반적인 로그인을 한 경우에 필요한 타입이 다릅니다.

그런데 그 다른 두경우를 나눠서 각각 코드를 작성하는 것은 매우 복잡하고 어려울 것입니다.

그래서 공통의 하나의 클래스를 만들어 UserDetails, Oauth2 User를 implement 해서 사용해야 합니다

기존에 만들었던 PrincipalDetails에 UserDetails만 implement 했지만

OAuth2 User 또한 같이 implement 해주고 필요한 메서드들을 아래와 같이 구현해 줍니다.

@Getter
@AllArgsConstructor
@RequiredArgsConstructor
public class PrincipalDetails implements UserDetails, OAuth2User {

    @Getter
    private User user;
    private String username;
    private String password;
    private Map<String, Object> attributes;

    //일반 로그인
    public PrincipalDetails(User user) {
        this.user = user;
    }

    //OAuth 로그인
    public PrincipalDetails(User user,Map<String,Object> attributes) {
        this.user = user;
    }

    @Override
    public <A> A getAttribute(String name) {
        return OAuth2User.super.getAttribute(name);
    }

    @Override
    public Map<String, Object> getAttributes() {
        return attributes;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(new SimpleGrantedAuthority(user.getAuthority()));
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public String getEmail() {
        return user.getEmail();
    }

    @Override
    public String getName() {
        return null;
    }
}

OAuth 로그인 후처리를 진행하는 principalOauth2UserService 클래스를 아래와 같이 바꿔봅시다.

구글 로그인 후 필요한 정보들을 가져와

DB를 체크하여 DB에 소셜로그인을 한 기록이 없다면 DB에 필요한 정보들을 저장하고

그렇지 않다면 저장하지 않는 로직입니다.

아까 콘솔로 찍어서 정보를 확인해본 코드들은 이제 필요 없는 코드니 지우시면 됩니다.

@Service
@RequiredArgsConstructor
public class PrincipalOauth2UserService extends DefaultOAuth2UserService {

    private final UserRepository userRepository;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {

        //System.out.println("getClientRegistration: " + userRequest.getClientRegistration());
        //System.out.println("getAccessToken: " + userRequest.getAccessToken());
        //System.out.println("getAttributes: " + super.loadUser(userRequest).getAttributes());

        OAuth2User oauth2User = super.loadUser(userRequest);

       String provider = userRequest.getClientRegistration()
       .getRegistrationId(); //google kakao facebook...
        String provideId = oauth2User.getAttribute("sub");
        String email = oauth2User.getAttribute("email");
        String username = oauth2User.getAttribute("name");
        String password = "OAuth2"; //Oauth2로 로그인을 해서 패스워드는 의미없음.
        String role = "ROLE_USER";

        Optional<User> user = userRepository.findByEmail(email);

        //이미 소셜로그인을 한적이 있는지 없는지
        if (user.isEmpty()) {
            User newUser = User.builder()
                .email(email)
                .username(username)
                .password(password)
                .phonenumber(null)
                .authority(role)
                .provider(provider)
                .build();

            userRepository.save(newUser);
            return new PrincipalDetails(newUser, oauth2User.getAttributes());
        } else {
            return new PrincipalDetails(user.get(), oauth2User.getAttributes());
        }
    }
}

그리고 SimpleUrlAuthenticationSuccessHandler을 상속받아 OAuth로그인 성공을 처리할 커스텀 클래스를 만들어 줍니다.

로그인 성공시 실행되는 onAuthenticationSuccess을 override 하여

OAuth 로그인이 성공적으로 실행될 시 수행할 작업을 코딩해 줍니다.

저는 기존에 만들어둔 ResponseDTO에 JWT토큰을 생성하여 담아서 프론트쪽에 보낼 것입니다.

주석 부분처럼 처리해서 전달하셔도 됩니다.

@Component
@RequiredArgsConstructor
public class OAuth2LoginSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    private final JwtProvider jwtProvider;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication authentication) throws IOException, ServletException {
        // OAuth2 로그인이 성공했을 때의 추가 작업을 수행
        // 여기에서는 JWT 토큰을 발급하고 형식에 맞게 return

        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
        String token = jwtProvider.createToken(principalDetails.getUser());

/*        // 응답 헤더에 JWT 토큰 추가
        response.addHeader("Authorization", "Bearer " + token);

        // JWT 토큰을 response에 담아서 전송
        response.setContentType("application/json");
        response.getWriter().write("{\"token\": \"" + token + "\"}");
        System.out.println("TOKEN : "+token);
*/

        ResponseDTO<Object> loginResponse = ResponseDTO.res(
            HttpStatus.valueOf(HttpServletResponse.SC_OK),
            "Login successful",
            new LoginResponse(principalDetails.getUser().getEmail(),
                principalDetails.getUser().getUsername(), token));

        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(loginResponse);

        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(jsonResponse);
    }
}

그리고 spring security 설정에 아래와 같이 성공 시 실행할 클래스를 추가해 줍니다.

방금 만든 커스텀 성공 핸들러를 추가하면 됩니다.

http.oauth2Login(oauth2 -> oauth2
        .userInfoEndpoint(
            userInfoEndpoint -> userInfoEndpoint.userService(principalOauth2UserService))
        .successHandler(oAuth2LoginSuccessHandler)
);

이제 다시 스프링을 실행하여 아래의 엔드포인트로 구글 로그인을 진행해 봅시다.

http://localhost:8080/oauth2/authorization/google

구글 로그인을 진행하여...

구글 로그인을 성공적으로 한다면 아래와 같이 JWT토큰을 발급받을 수 있습니다.

발급받은 JWT토큰을 헤더에 넣어 유저 정보를 가져오는 API도 잘 실행이 됩니다!

이후 업데이트

OAuth2LoginSuccessHandler를 다음과 같이 변경하여 프론트단으로 JWT토큰을 쿼리스트링에 담아

리디렉트 되도록 하고 로그인 처리를 하도록 변경했습니다.

이유는 이렇게 발급한 JWT토큰은 프론트단에서 추출하여 사용을 하지 못하기 때문입니다.

@Component
@RequiredArgsConstructor
public class OAuth2LoginSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {

    private final JwtProvider jwtProvider;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication authentication) throws IOException, ServletException {

        PrincipalDetails principalDetails = (PrincipalDetails) authentication.getPrincipal();
        String token = jwtProvider.createToken(principalDetails.getUser());
        String email = principalDetails.getEmail();
        String name = principalDetails.getUsername();

        //코드 내로 리디렉트 설정
        //String redirectUrl = "/user/oauth-success?token="+token;

        //한국어 인코딩 설정
        String encodedName = URLEncoder.encode(name, StandardCharsets.UTF_8.toString());
        
        String redirectUrl = "프론트도메인?token=" + token
        +"&email="+email+"&name="+encodedName;
        
        getRedirectStrategy().sendRedirect(request, response, redirectUrl);
    }
}

프론트단 코드 - 구글 로그인 버튼 생성

해당 버튼으로 누르면 oauth2/authorization/google로 요청을 하게 됩니다.

import styled from '@emotion/styled';
import { Button } from '@chakra-ui/react';
import NaverIcon from '../../assets/icons/btn_naver.svg';
import GoogleIcon from '../../assets/icons/btn_google.svg';

const SocialLoginContainer = () => {
  const handleSocialLogin = (service: string) => {
    window.location.href = `https://yanoljaschool.site:8080/oauth2/authorization/${service}`;
  };

  return (
    <StyledContainer>
      <StyledButton
        backgroundColor="#03C759"
        variant="none"
        onClick={() => {
          handleSocialLogin('naver');
        }}
      >
        <img src={NaverIcon} alt="naver" />
        네이버로 시작하기
      </StyledButton>
      <StyledButton
        style={{ color: 'black' }}
        onClick={() => {
          handleSocialLogin('google');
        }}
      >
        <img src={GoogleIcon} alt="google" style={{ paddingRight: '10px' }} />
        구글로 시작하기
      </StyledButton>
    </StyledContainer>
  );
};

export default SocialLoginContainer;

const StyledContainer = styled.div`
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  width: 100%;
  margin: 5px;
`;

const StyledButton = styled(Button)`
  margin: 5px;
  color: white;
  &:hover {
    opacity: 0.9;
  }
`;

프론트단으로 리디렉트 되면 아래의 코드처럼 쿼리스트링으로 JWT토큰을 받을 수 있습니다.

그리고 그렇게 받은 JWT토큰을 쿠키에 저장하게 되고 로그인처리를 프론트단에서 진행하게 됩니다.

import { useEffect } from 'react';
import { useNavigate } from 'react-router-dom';
import { setCookies } from '../../../utils/utils';
import LoadingCircle from '../../../components/Loading';

const SocialLoginLoading = () => {
  const navigate = useNavigate();

  useEffect(() => {
    const handleLogin = async () => {
      /* eslint-disable */
      const urlParams = new URLSearchParams(location.search);
      const token = urlParams.get('token');
      const userName = urlParams.get('name');
      const userEmail = urlParams.get('email');
      
      if (token && userEmail && userName) {
        await setCookies(userEmail, userName, token);
        navigate('/');
      } else {
        alert('로그인에 실패하셨습니다.');
        navigate('/login');
      }
    };

    handleLogin();
    /* eslint-enable */
  }, []);
  return <LoadingCircle />;
};

export default SocialLoginLoading;

실제 프론트 배포 페이지에서 버튼을 클릭하면..

아래처럼 구글 로그인창이 뜨게 되고

구글 로그인을 성공하게 되면

JWT토큰을 쿠키에 저장한 채 메인페이지로 가게 됩니다.

OAuth 로그인이 성공적으로 된 것이죠.

내 정보를 확인해 보면 구글 이메일을 통해 로그인이 된 것을 볼 수 있습니다.

전체적인 과정을 정리하자면 아래 사진과 같습니다.

네이버 OAuth 로그인 까지 추가하는 과정을

아래 글에 이어서 작성하겠습니다.

https://yusang.tistory.com/147

Spring, OAuth2 + JWT 를 활용하여 소셜 로그인 구현하기 2편 (구글 및 네이버) [Spring 3.1.5, java 17]

yusang.tistory.com

spring jpa에 Querydsl 적용하기 [spring 3.1.5, java 17]

Yusang — Wed, 6 Dec 2023 22:23:07 +0900

개발하고 있는 프로젝트에 Querydsl을 적용해 보려고 합니다.

Querydsl의 장점

유연성 및 강력한 검색 기능 :
Query DSL을 사용하면 복잡한 검색 조건을 표현할 수 있습니다.
진행하고 있는 프로젝트 메인페이지 및 예약 검사 시

jpa repository를 통해 여러 복잡한 조건을 거쳐 DB에 여러 번 접근하게 되는데
QueryDSL을 활용하게 된다면 그럴 필요 없이 검색 조건과 필터를 조합해 정확한 결과를 얻을 수 있습니다.

가독성 및 이해도 향상 :
Query DSL은 일반적으로 사람이 이해하기 쉬운 구조를 가지고 있기에 이는 쿼리를 작성하고 이해하는 데 도움이 되며,

코드의 가독성을 높여 유지보수를 쉽게 만들 수 있습니다.

성능 향상 :
적절한 쿼리를 작성함으로써 성능을 향상할 수 있습니다.

그럼 그냥 JPQL 쓰면 안 되나? QueryDSL을 사용하는 이유는 뭘까요?

성능 차이

JPQL:
- JPQL은 JPA를 사용하여 작성된 객체 지향 쿼리 언어입니다.
- JPQL 쿼리는 **런타임(애플리케이션 실행 중)**에 문자열로 해석되어 SQL로 변환되는데,
  이 과정에서 쿼리의 오타나 잘못된 필드명으로 인한 오류가 런타임에만 발견됩니다.
- 복잡한 쿼리의 경우 JPQL로 작성하기 어려울 수 있고, 유지보수에 어려움이 있을 수 있습니다.
Querydsl:
- Querydsl은 타입 안전한 쿼리를 작성할 수 있는 프레임워크입니다.
- 컴파일 시점에 쿼리의 문법 오류를 발견할 수 있어, 안정성이 높습니다.
- 동적 쿼리 작성이 용이하며, 복잡한 쿼리도 더 가독성 있게 작성할 수 있습니다.
- JPQL에 비해 약간 더 빠른 성능을 제공할 수 있지만,
  이는 상황에 따라 다를 수 있으며 대체로 차이는 미미합니다.

실무에서는?

JPQL:
- 간단한 쿼리나, 프로젝트에서 추가적인 의존성을 피하고자 할 때 선호됩니다.
- 표준 JPA만을 사용하고 싶은 경우에 적합합니다.
Querydsl:
- 복잡한 쿼리나 동적 쿼리가 필요한 경우에 선호됩니다.
- 타입 안전성과 가독성이 중요한 프로젝트에서 유리합니다.
- 초기 설정 필요하고, 학습 곡선이 높지만,
  장기적으로 보았을 때 유지보수와 개발 효율성 측면에서 이점을 제공합니다.
결국 성능적인 측면에서 JPQL과 Querydsl 사이에는 큰 차이가 없습니다.
주된 차이점은 가독성, 유지보수성, 그리고 타입 안전성에 있습니다.
실무에서는 복잡한 쿼리를 다루어야 하고 유지보수성, 런타임시 에러를 회피하기 위해
Querydsl을 선호하는 경향이 있습니다.

장단점 비교:

JPQL:
- 장점: JPA 표준의 일부이므로 JPA 구현체에서 지원되는 범위 내에서 사용할 수 있습니다.
- 단점: 동적 쿼리 작성이 어렵고, 문자열 기반으로 작성되어 오타가 발생할 가능성이 있습니다.
QueryDSL:
- 장점: 정적으로 쿼리를 작성하므로 컴파일 시간에 오류를 확인할 수 있고, 동적 쿼리 작성이 편리합니다.
  코드 자동 완성과 IDE 지원이 우수합니다.
- 단점: JPQL이나 SQL과 달리 학습 곡선이 존재하며, 프로젝트에 라이브러리를 추가해야 합니다.

그렇기에 복잡한 쿼리를 추가하여 사용하는 경우에는

유지 보수 측면에서 용이한 QueryDsl을 추가해서 사용해 보려고 합니다.

gradle 추가

dependencies {
    // Querydsl 추가
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    annotationProcessor 'com.querydsl:querydsl-apt:5.0.0:jakarta'
    annotationProcessor "jakarta.annotation:jakarta.annotation-api"
    annotationProcessor "jakarta.persistence:jakarta.persistence-api"
}

//querydsl
def querydslDir = "src/main/generated"

sourceSets {
    main.java.srcDirs += [ querydslDir ]
}

tasks.withType(JavaCompile) {
    options.getGeneratedSourceOutputDirectory().set(file(querydslDir))
}

clean.doLast {
    file(querydslDir).deleteDir()
}

추가 후 gradle - other - compileJava 실행

실행하고 나면 아래와 같이 Qclass가 생성됩니다.

이를 통해 Querydsl을 사용할 수 있습니다.

customRepository interface 생성

@Repository
public interface AccommodationRepositoryCustom {

    Page<Long> findAccommodationIds(AccommodationCategory category, boolean isDomestic,
        Pageable pageable, LocalDate startDate, LocalDate endDate,int numberOfPeople);
}

메인페이지에서 업체를 조회하는데 아래와 같은 쿼리로 조건을 필터링해서

조건에 맞는 업체만을 response 하게 됩니다.

SELECT DISTINCT a.accommodation_id
FROM accommodation_rooms
JOIN accommodation a ON a.accommodation_id = accommodation_rooms.accommodation_id
LEFT JOIN reservations r ON accommodation_rooms.room_id = r.room_id AND (r.start_date > NOW() OR r.start_date IS NULL)
WHERE a.category = :category
AND (
    NOT (
        (:startDate <= r.end_date AND :endDate >= r.start_date)
        OR (:startDate >= r.start_date AND :endDate <= r.end_date)
    )
    OR (r.start_date IS NULL AND r.end_date IS NULL)
    OR (r.payment_completed IS FALSE OR r.payment_completed IS NULL)
    OR (r.deleted_at is not null)
)
and a.is_domestic = :isDomestic
and (:numberOfPerson>=accommodation_rooms.min_capacity and :numberOfPerson<= accommodation_rooms.max_capacity)
limit :page,:size

customRepository을 implement 한 클래스 작성 후

위 쿼리를 Querydsl로 아래와 같이 반영해서 작성할 수 있습니다.

public class AccommodationRepositoryImpl implements AccommodationRepositoryCustom {

    private final JPAQueryFactory queryFactory;

    public AccommodationRepositoryImpl(EntityManager entityManager) {
        this.queryFactory = new JPAQueryFactory(entityManager);
    }

    @Override
    public Page<Long> findAccommodationIds(AccommodationCategory category, boolean isDomestic,
        Pageable pageable,LocalDate startDate, LocalDate endDate,int numberOfPeople) {
        QAccommodation a = QAccommodation.accommodation;
        QAccommodationRooms ar = QAccommodationRooms.accommodationRooms;
        QReservations r = QReservations.reservations;

        BooleanExpression reservationCondition = r.startDate.after(LocalDate.now())
            .or(r.startDate.isNull());

        BooleanExpression conflictingCondition = r.deletedAt.isNotNull()
            .or(r.paymentCompleted.isFalse().or(r.paymentCompleted.isNull()))
            .or(r.endDate.before(startDate))
                .or(r.startDate.after(endDate));

        BooleanExpression capacityCondition =
            ar.minCapacity.loe(numberOfPeople).and(ar.maxCapacity.goe(numberOfPeople));

        List<Long> result = queryFactory.selectDistinct(a.accommodationId)
            .from(ar)
            .join(a).on(ar.accommodation.accommodationId.eq(a.accommodationId))
            .leftJoin(r).on(ar.roomId.eq(r.room.roomId).and(reservationCondition))
            .where(a.category.eq(category)
                .and(a.isDomestic.eq(isDomestic))
                .and(conflictingCondition)
                .and(capacityCondition))
            .offset(pageable.getOffset())
            .limit(pageable.getPageSize())
            .fetch();

        return new PageImpl<>(result, pageable, result.size());
    }
}

Querydsl 적용 후 service단의 코드가 매우 간소화되었습니다.

적용 전

@Transactional
    public List<AccommodationFindResponse> getAccommodationsInMainPage(
        PrincipalDetails principalDetails, String categoryStr,
        boolean isDomestic, Pageable pageable, LocalDate startDate, LocalDate endDate,
        int numberOfPeople) {
        AccommodationCategory category = AccommodationCategory.valueOf(categoryStr.toUpperCase());

        Page<Accommodation> accommodations = accommodationRepository.findByCategoryAndIsDomestic(
            category, isDomestic, pageable);
        List<Accommodation> accommodationList = new ArrayList<>();

        boolean capacityAvailable = false;
        for (Accommodation accommodationContents : accommodations) {
            List<AccommodationRooms> roomlist = accommodationContents.getRoomlist();
            int fullRoomCount = 0;

            for (AccommodationRooms accommodationRoomContents : roomlist) {
                if (accommodationRoomContents.getMaxCapacity() >= numberOfPeople &&
                    accommodationRoomContents.getMinCapacity() <= numberOfPeople) {
                    capacityAvailable = true;
                }
                //예약 충돌 검사
                if (reservationRepository.findConflictingReservations(
                    accommodationRoomContents.getRoomId(), startDate, endDate).isPresent()) {
                    fullRoomCount++;
                }
            }
            if (fullRoomCount < roomlist.size() && capacityAvailable) {
                accommodationList.add(accommodationContents);
            }
        }
        
        ...
        ...
        ...
        
        
        return accommodationFindResponses;
    }

적용 후

@Transactional
public List<AccommodationFindResponse> getAccommodationsInMainPage(
    PrincipalDetails principalDetails, AccommodationCategory category,
    boolean isDomestic, Pageable pageable, LocalDate startDate, LocalDate endDate,
    int numberOfPeople) {
    Page<Long> acIds = accommodationRepositoryCustom.findAccommodationIds(
        category, isDomestic, pageable, startDate, endDate, numberOfPeople);

    List<Accommodation> accommodationList =
        acIds.stream().map(accommodationRepository::findByAccommodationId).toList();
   ...
   ...
   ...

    return accommodationFindResponses;
}

진행하고 있는 프로젝트에서 메인페이지에서 클라이언트의 요구사항에 맞게 업체를 여러 가지 조건으로 필터링해서

업체정보를 전달해야 했었는데 Querydsl 적용으로 인해 검색 조건과 필터를 조합하여

정확한 결과를 얻을 수 있었고 service 로직이 매우 간소화되었습니다!

또한 Querydsl은 일반적으로 사람이 이해하기 쉬운 구조를 가지고 있어

쿼리를 작성하고 이해하는 데 도움이 되며 IDE에서도 체크가 가능하기 때문에 유지보수가 매우 용이합니다!

필요한 데이터에 접근할 때 어쩔 수 없이 복잡한 쿼리를 사용해야 하는 경우

Querydsl을 적극적으로 활용하면 좋을 것 같습니다.

springboot certbot으로 ssl인증서 받아서 https로 배포하기

Yusang — Thu, 30 Nov 2023 11:12:58 +0900

ssl 인증서를 받기 위해서는 등록할 도메인이 필요합니다.

그래서 저는 가비아에서 1900짜리 제일 싼 도메인을 1년 구매했습니다.

그리고 배포한 인스턴스의 주소를 등록해 주었습니다.

https://certbot.eff.org/instructions?ws=other&os=ubuntufocal

Certbot Instructions

Tagline

certbot.eff.org

저는 gcp 인스턴스에서 spring 프로젝트를 배포하고 있었고

운영체제는 ubuntu 20이었기에 아래처럼 선택했습니다.

올바르게 위 사이트에서 선택을 해서 따라 하면 됩니다.

sudo snap install --classic certbot

sudo ln -s /snap/bin/certbot /usr/bin/certbot

sudo certbot certonly --standalone

사이트에서 알려주는 방법대로 쭉 따라 하고 저는 --standalone 방법을 선택했습니다.

이메일을 입력하고 도메인을 입력하라는 메시지가 나오면 입력하면 됩니다.

그 후 파일이 저장된 경로가 나오고 그 경로로 이동해야 합니다.

그 후 아래 명령어를 통해 keystore.p12 파일을 얻어야 합니다.

이때 입력하라고 한 비밀번호를 기억하고 있어야 합니다.

 openssl pkcs12 -export -in fullchain.pem -inkey privkey.pem -out keystore.p12 -name name -CAfile chain.pem -caname root

그럼 아래처럼 keystore.p12 파일이 생성된 걸 확인할 수 있습니다.

이제 이 파일을 파일 다운로드를 통해 내 컴퓨터로 가져와야 합니다.

이때 주의 해야 할 점이 있습니다. 파일과 파일의 하위 폴더 모두 읽기 권한이 없기 때문에

chmod 777 명령어를 통해 설정을 바꿔야 합니다.

저는 이때 구글에서 따로 메시지를 안 알려주고 다운로드를 할 수 없다고

에러만 나서 원인을 찾는데 시간이 걸렸습니다.

원인은 다운로드하려는 파일만 읽기 권한을 주고 하위 폴더에 읽기 권한을 주지 않아서였습니다.

이렇게 가져온 인증서를 아래와 같이 spring프로젝트 resoureces 하위에 넣고

yml파일에 아래와 같이 추가하면 됩니다.

이때 비밀번호는 위에서 입력한 비밀번호입니다.

참고로 same-site : None 이 코드는 쿠키 관련 코드니 필요 없어도 됩니다.

저는 사용하고 있는 프로젝트에서 필요하기에 저는 추가했습니다.

server:
  servlet:
    session:
      cookie:
        same-site: None
  ssl:
    key-store: classpath:keystore.p12
    key-store-type: PKCS12
    key-store-password: 123456

저는 도커 이미지로 배포하고 있었기에 아래와 같이 도커파일을 수정해서

도커 이미지를 생성해서 도커허브에 다시 올렸습니다.

FROM openjdk:17-jdk-slim-buster
COPY build/libs/yanolja-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
# 작업 디렉토리 생성
WORKDIR /app

# 소스 코드 및 .env 파일 복사
COPY . .

# .env 파일을 WORKDIR로 복사
COPY .env .env

# keystore.p12 파일을 WORKDIR로 복사
COPY src/main/resources/keystore.p12 keystore.p12

ENTRYPOINT ["java", "-jar", "/app.jar"]

그리고 gcp에서 도커를 다시 실행시키고 api를 확인해 보았습니다.

https 인증이 아주 잘 되고 있는 걸 확인할 수 있습니다!

GCP 에서 springboot 프로젝트 docker로 배포하기

Yusang — Sat, 25 Nov 2023 12:43:48 +0900

GCP로 이동합니다.

Google 클라우드 플랫폼

로그인 Google 클라우드 플랫폼으로 이동

accounts.google.com

vm인스턴스 -> 인스턴스 생성

아래와 같이 설정했습니다.

가장 저렴한 비용으로 할 수 있습니다.

OS는 ubuntu로 했습니다.

vpc 네트워크 -> 외부 고정 ip 주소 예약을 클릭해 고정 ip주소를 할당합니다.

생성된 인스턴스에 ssh를 통해 연결하고 도커를 설치합니다

아래는 도커공식문서에서 가져온 설치 방법입니다.

Install Docker Engine on Ubuntu

Jumpstart your client-side server applications with Docker Engine on Ubuntu. This guide details prerequisites and multiple methods to install Docker Engine on Ubuntu.

docs.docker.com

$ sudo apt-get update
$ sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

$ sudo mkdir -m 0755 -p /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
$ sudo docker --version

docker compose 또한 설치합니다.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
$ sudo chmod +x /usr/local/bin/docker-compose
$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
$ docker-compose -v

도커 이미지를 생성하기 위한 dockerfile을 생성해야 합니다.

인텔리제이에서 프로젝트 최상단에 Dockerfile을 생성하면 됩니다.

저는 env파일을 사용해 key값을 저장했기에 아래와 같은 docker file을 생성했습니다.

FROM openjdk:17-jdk-slim-buster
COPY build/libs/yanolja-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
# 작업 디렉토리 생성
WORKDIR /app

# 소스 코드 및 .env 파일 복사
COPY . .

# .env 파일을 WORKDIR로 복사
COPY .env .env

ENTRYPOINT ["java", "-jar", "/app.jar"]

yml파일에서 datasource부분을 env파일에 있는 값을 사용하는 방식으로 사용했습니다.

DB는 GCP에 Cloud SQL를 사용했습니다.

spring:
  config:
    activate:
      on-profile: docker

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: ${DBURL}
    username: ${DBUSER}
    password: ${DBUSER}

bootJar을 통해 jar파일을 빌드해 줍니다

docker hub에서 repositories를 생성합니다.

Docker Hub Container Image Library | App Containerization

Build and Ship any Application Anywhere Docker Hub is the world's easiest way to create, manage, and deliver your team's container applications. Create your account Signing up for Docker is fast and free. Continue with GoogleContinue with GitHubContinue wi

hub.docker.com

이제 도커 이미지를 만들어 줍니다.

docker build -t liyusang799/test . -> .을 붙어야 합니다.

docker build -t (본인닉네임)/(레포이름) .

그리고

docker push liyusang799/test

docker hub로 push합니다.

아까 생성한 vm 인스턴스를 ssh를 통해 연결합니다.

sudo vim docker-compose.yml을 통해 docker-compose.yml파일을 생성합니다.

version: '3'
services:
  application :
    image : test
    env_file: .env
    environment:
      SPRING_DATASOURECE_URL: 
      SPRING_DATESOURECE_USERNAME: 
      SPRING_DATASOURCE_PASSWORD: 
      SPRING_PROFILES_ACTIVE: dev
    restart: always
    container_name: test
    ports:
      - "8080:8080"

그리고 저는 env파일에서 값을 가져오는 코드들이 있어 env파일을 같은 경로에 넣어주어야 합니다.

gcp에서 지원하는 파일업로드를 통해 같은 경로에 env파일을 넣었습니다.

그리고 docker hub에서 accesstoken을 발급받고 sudo docker login -u (이름)을 통해 로그인해 줍니다.

password는 토큰을 발급받아서 확인할 수 있습니다.

sudo docker pull liyusang799/test

sudo docker pull (이름)/(레포이름)

을 통해서 생성된 도커 이미지를 가져와서

아까 만들어둔 docker-compose.yml을 실행시키면 됩니다.

sudo docker compose up이 명령어입니다.

[Spring] request시 notnull값 controllerAdvice로 처리해서 response보내기

Yusang — Fri, 24 Nov 2023 23:13:00 +0900

public record CreateReservationRequest(
    @NotNull(message = "startDate cannot be null")
    LocalDate startDate,

    @NotNull(message = "endDate cannot be null")
    LocalDate endDate,

    @NotNull(message = "numberOfPerson cannot be null")
    Integer numberOfPerson
) {

    public Reservations toEntity(
        User user, AccommodationRooms rooms, boolean paymentCompleted) {
        return Reservations.builder()
            .user(user)
            .rooms(rooms)
            .startDate(startDate)
            .endDate(endDate)
            .numberOfPerson(numberOfPerson)
            .paymentCompleted(paymentCompleted)
            .build();
    }
}

@NotNull 어노테이션을 사용하면 해당 필드에 null 값이 들어오지 않도록 강제할 수 있습니다.

위와 같은 코드에서 request로 notnull값에 null이 들어오는 경우 Spring은 자동으로

MethodArgumentNotValidException을 던지게 됩니다.

하지만 이 예외는 핸들링되지 않기 때문에 직접 핸들링해서

알맞은 형식으로 response를 보내 주어야 합니다. 그렇게 해야 프론트개발자 입장에서 처리할 수 있습니다.

@ControllerAdvice 에서 아래와 같이 MethodArgumentNotValidException을 핸들링할 수 있습니다.

import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;

@RestControllerAdvice
public class GlobalExceptionRestAdvice {

    //notnull값을 넣지 않은 경우 에러 핸들링
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ResponseDTO<Object>> handleValidationExceptions(
        MethodArgumentNotValidException e) {

        BindingResult bindingResult = e.getBindingResult();

        //Notnull어노테이션에 작성한 에러메시지가 뜨도록 메시지 바인딩
        Map<String, String> fieldErrors = bindingResult.getFieldErrors()
            .stream()
            .collect(Collectors.toMap(FieldError::getField, FieldError::getDefaultMessage));

        log.error(e.getMessage(), e);
        return ResponseEntity
            .status(HttpStatus.BAD_REQUEST)
            .body(
                ResponseDTO.res(HttpStatus.BAD_REQUEST, fieldErrors));
    }
}

실제로 null일 수 없는 값을 null로 하여 요청하면 커스텀 핸들러가 에러를 처리해서 response를 보내게 됩니다.