(Spring) Spotify API 설정 (searchTracks)

🐶 Spotify 

✅ 음악 스트리밍 서비스
✔️ 주요 기능: 전 세계의 음악, 팟캐스트를 실시간 스트리밍으로 감상할 수 있음
✔️ 플랫폼: 모바일, 웹, 데스크탑 등 다양한 기기에서 사용 가능

 

 

🚩개인 프로젝트에 맞춰 작성한 코드입니다. 필요에 맞게 수정하시기 바랍니다.

🐶 API 설정 

✨ Spotify 의존성 추가 및 키 값 설정

✅ build.gradle
implementation 'se.michaelthelin.spotify:spotify-web-api-java:7.0.0'

✅ application.properties (키 값은 환경변수로 등록)
spotify.client.id=${SPOTIFY_CLIENT_ID}
spotify.client.secret=${SPOTIFY_CLIENT_SECRET}

 

✨ SpotifyConfig 설정

package com.sigorzav.singmate.config;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.hc.core5.http.ParseException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import se.michaelthelin.spotify.SpotifyApi;
import se.michaelthelin.spotify.exceptions.SpotifyWebApiException;
import se.michaelthelin.spotify.model_objects.credentials.ClientCredentials;
import se.michaelthelin.spotify.requests.authorization.client_credentials.ClientCredentialsRequest;

import java.io.IOException;

/**
 * ✅ Spotify API Config
 * - Access Token 생성
 * - 만료여부 체크 및 자동 갱신
 * - Refresh Token 갱신 미생성 (Client Credentials Flow 방식)
 */
@Slf4j
@Component
public class SpotifyConfig {

    @Getter
    private final SpotifyApi spotifyApi;
    private final ClientCredentialsRequest clientCredentialsRequest;

    // Access Token의 만료 시간 (밀리초)
    private long tokenExpirationTime;

    public SpotifyConfig(
            @Value("${spotify.client.id}") String spotifyClientId,
            @Value("${spotify.client.secret}") String spotifyClientSecret
    ) {
        // Spotify API 설정
        this.spotifyApi = new SpotifyApi.Builder()
                .setClientId(spotifyClientId)
                .setClientSecret(spotifyClientSecret)
                .build();

        // Client Credentials Flow 요청 객체 생성
        this.clientCredentialsRequest = spotifyApi.clientCredentials().build();

        log.info("SpotifyConfig initialized with clientId: {}", spotifyClientId);

        // Access Token 요청
        requestAccessToken();
    }

    /**
     * Access Token 요청 및 설정
     */
    private void requestAccessToken() {
        try {
            // Client Credentials Flow를 통해 Access Token 요청
            ClientCredentials clientCredentials = clientCredentialsRequest.execute();

            // Spotify API에 Access Token 설정
            spotifyApi.setAccessToken(clientCredentials.getAccessToken());

            // 유효시간 설정: 1시간
            this.tokenExpirationTime = System.currentTimeMillis() + 3600 * 1000;
            log.info("Access Token retrieved successfully! Expires in: {} seconds", clientCredentials.getExpiresIn());
        } catch (IOException | SpotifyWebApiException | RuntimeException | ParseException e) {
            log.error("Error while retrieving access token: ", e);
        }
    }

    // Access Token 만료 및 갱신
    public void ensureAccessToken() {
        if (isAccessTokenExpired()) {
            requestAccessToken();
        }
    }

    // Access Token 만료 여부 확인
    private boolean isAccessTokenExpired() {
        return System.currentTimeMillis() >= tokenExpirationTime;
    }
}

 

✨ Spotify API 호출

✅ Controller
package com.sigorzav.singmate.song.controller;

import com.sigorzav.singmate.api.response.ApiResponse;
import com.sigorzav.singmate.song.dto.SongDTO;
import com.sigorzav.singmate.song.service.SongService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("api/v1/song/")
@RequiredArgsConstructor
@Tag(name = "SongControllerV1", description="노래 관련 기능 API - V1")
public class SongControllerV1 {

    private final SongService songService;

    @GetMapping("search")
    @ResponseBody
    @Operation(summary = "노래 검색", description = "가수나, 곡의 이름 등으로 노래를 검색합니다.", tags = {"노래 관리"})
    public ApiResponse<Object> searchSongs(@RequestParam String query) {
        return songService.searchSongs(query);
    }
}

✅ Service
package com.sigorzav.singmate.song.service;

import com.sigorzav.singmate.api.response.ApiResponse;
import com.sigorzav.singmate.api.service.SpotifyService;
import com.sigorzav.singmate.common.enums.MessageEnum;
import com.sigorzav.singmate.exception.CustomException;
import com.sigorzav.singmate.song.dto.SongDTO;
import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service
@Transactional
@RequiredArgsConstructor
public class SongServiceImpl implements SongService {

    private final SpotifyService spotifyService;

    /**
     * ✅ 노래 검색
     * ✔️ ex) query :: 좋은날 
     */
    @Override
    public ApiResponse<Object> searchSongs(String query) {
        log.info("songSearch request processing. Query: {}", query);

        try {
            List<SongDTO> songs = spotifyService.searchSongsFromSpotify(query);
            return ApiResponse.success(songs);
        } catch (Exception e) {
            log.error("searchSongs error", e);
            throw new CustomException(MessageEnum.SONG_SEARCH_FAIL.getMsg(), HttpStatus.BAD_REQUEST);
        }
    }
}

✅ Spotify Service
package com.sigorzav.singmate.api.service;

import com.sigorzav.singmate.config.SpotifyConfig;
import com.sigorzav.singmate.song.dto.SongDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.hc.core5.http.ParseException;
import org.springframework.stereotype.Service;
import se.michaelthelin.spotify.SpotifyApi;
import se.michaelthelin.spotify.exceptions.SpotifyWebApiException;
import se.michaelthelin.spotify.model_objects.specification.Track;
import se.michaelthelin.spotify.requests.data.search.simplified.SearchTracksRequest;

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

@Slf4j
@Service
@RequiredArgsConstructor
public class SpotifyService {

    private final SpotifyConfig spotifyConfig;

    /**
     * 노래 검색
     */
    public List<SongDTO> searchSongsFromSpotify(String query) {
        SpotifyApi spotifyApi = spotifyConfig.getSpotifyApi();

        // Access Token 만료 확인 및 갱신
        spotifyConfig.ensureAccessToken();

        try {
            SearchTracksRequest searchTracksRequest = spotifyApi.searchTracks(query).build();
            Track[] tracks = searchTracksRequest.execute().getItems();

            return convertToSongs(tracks);
        } catch (IOException | SpotifyWebApiException | RuntimeException | ParseException e) {
            log.error("Spotify API 검색 오류 발생", e);
            throw new RuntimeException("Spotify API 검색이 실패했습니다.", e);
        }
    }

    /**
     * 노래 검색 - 결과 리스트 생성
     */
    private List<SongDTO> convertToSongs(Track[] tracks) {
        List<SongDTO> songs = new ArrayList<>();

        for (Track track : tracks) {
            if (track.getName() == null) {
                continue;
            }

            String songTitle = track.getName();
            String songArtist = "Unknown Artist";
            String songReleaseDate = "Unknown Release Date";
            String songThumbnailUrl = "Unknown Image Url";

            if (track.getArtists() != null && track.getArtists().length > 0 && track.getArtists()[0].getName() != null) {
                songArtist = track.getArtists()[0].getName();
            }

            if (track.getAlbum() != null && track.getAlbum().getReleaseDate() != null) {
                songReleaseDate = track.getAlbum().getReleaseDate();
            }

            if (track.getAlbum() != null && track.getAlbum().getImages() != null && track.getAlbum().getImages().length > 0) {
                songThumbnailUrl = track.getAlbum().getImages()[0].getUrl();
            }

            SongDTO songDTO = new SongDTO();
            songDTO.setSongTitle(songTitle);
            songDTO.setSongArtist(songArtist);
            songDTO.setSongReleaseDate(songReleaseDate);
            songDTO.setSongThumbnailUrl(songThumbnailUrl);
            songs.add(songDTO);
        }

        return songs;
    }
}