정시화의 공부기록

HttpMediaTypeNotSupportedException: Content type 'application/json;charset=UTF-8' not supported

나는시화 — Wed, 26 Mar 2025 22:30:51 +0900

원인.

ajax로 requestBody를 서버에 넘겨주려고 할 때 발생한 오류.

jackson 라이브러리는 이미 추가했는데 계속 발생한다.

결론부터 말하면 jackson은 get으로 시작하는 메서드 때문에 발생한 오류!

@Getter
@Setter
public class RecommendSearchRequest extends BookSearchRequest {
    private String rcmdTnY; // 추천년월
    private String rcmdTnM; // 추천월
    private Integer rcmdTnYm; // 추천연월
    private Long homepageSn;
    private String homepageSns;

    public void initRcmdTnYm() {
        LocalDate now = LocalDate.now();
        String nowStr = StringUtil.convertLocalDateToString(now, "yyyyMMdd");
        this.rcmdTnM = nowStr.substring(4, 6);
        this.rcmdTnY = nowStr.substring(0, 4);
        this.rcmdTnYm = Integer.parseInt(nowStr.substring(0, 6));
    }


// 이 아래 메서드가 문제!! 
    public MultiValueMap<String, String> getNationLibSearchQueryParams() {

        MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<>();

        // API 요청을 위한 startRowNumApi, endRowNumApi 계산
        if (StringUtils.hasText(this.rcmdTnY) && StringUtils.hasText(this.rcmdTnM)) {
            YearMonth ym = YearMonth.of(Integer.parseInt(this.rcmdTnY), Integer.parseInt(this.rcmdTnM));
            LocalDate startDate = ym.atDay(1);
            LocalDate endDate = ym.atEndOfMonth();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");

            queryParams.add("start_date", startDate.format(formatter));
            queryParams.add("end_date", endDate.format(formatter));
        }
        queryParams.add("Key", getKey());
        return queryParams;
    }

    public RecommendSearchRequest() {

    }
}

get으로 시작하는 메서드가 있으면 jackson이 getter로 인식하기 때문에 nationLibSearchQueryParams 프로퍼티에 대응하는 setter를 찾는 과정에 생기는 오류이다.

해결방법

간단하게 메서드 이름을 변경하여 해결 완료함.

추가로 json 타입의 데이터를 requestBody로 매핑할 때 순서가

1. 기본 생성자로 객체 생성

2. setter로 필드 값 매핑

그래서 처음에는 상속 관계인 부모 클래스와 조상 클래스에 문제가 아닐까 생각함.

기본 생성자가 잘 만들어지는 지도 확인이 필요.

티베로 java.lang.AbstractMethodError

나는시화 — Wed, 26 Feb 2025 21:03:55 +0900

1. 에러 내용 및 원인

먼저 gpt한테 물어봤다.

java.lang.AbstractMethodError는 Java 애플리케이션이 추상 메소드를 호출하려 할 때 해당 메소드의 구현을 찾지 못하면 발생하는 에러입니다. 주로 다음과 같은 경우에 나타납니다:

버전 불일치: 컴파일 시점에 사용된 클래스와 런타임에 로드되는 클래스가 서로 다른 버전일 때, 인터페이스나 추상 클래스의 메소드 구현이 누락되어 발생할 수 있습니다.
JDBC 드라이버 문제: Tibero DB와 같이 특정 데이터베이스를 사용할 때, 해당 DB의 JDBC 드라이버가 Java에서 기대하는 인터페이스를 완전히 구현하지 않았거나, 드라이버 버전이 현재 사용 중인 Java 버전과 호환되지 않을 때 발생할 수 있습니다.

해결 방법:

JDBC 드라이버 확인: Tibero DB에 맞는 최신 JDBC 드라이버를 사용하고 있는지 확인하세요.
라이브러리 버전 일치: 애플리케이션에서 참조하는 라이브러리(예: JDBC API)와 실제 런타임에 사용되는 라이브러리의 버전이 일치하는지 검토하세요.
클린 빌드: 가끔은 빌드 캐시 문제일 수 있으므로, 클린 빌드를 진행해보고 문제가 해결되는지 확인합니다.

JDBC 드라이버 문제라고 함.

현재 사용하고 있는 jdbc는 tibero6.jar인데, 티베로6은 자바 1.6 버전 기반으로 알고 있다.

위 티베로가 자바 1.7인가? 1.8 부터 도입한 기능을 사용하려고 해서 발생한 문제이기 때문에 발생한 문제!

2. 해결방법

jdbc 자바 1.8 버전 기반으로 만든 tibero6-jdbc-18.jar을 설치해주면 됨.

tibero6-jdbc-18.jar

1.70MB

p.s 그지같은 티베로.

jpa OutOfMemoryException

나는시화 — Mon, 24 Feb 2025 22:01:14 +0900

1. 상황

외부 API를 사용할 때마다 로그를 DB에 저장 -> 데이터가 너무 많이 쌓여서 데이터를 삭제하는 스케줄러 작성 ->

데이터를 한번에 70만 건을 삭제하려고 하니깐 OutOfMemoryException이 발생!

2. 원인

public interface ApiLogRepository extends JpaRepository<ApiLog, Long>, CustomApiLogRepository{

    void deleteApiLogsByRegistrationDateLessThan(LocalDateTime localDateTime);

}

위 메서드가 문제였다.

나는 쿼리를 DB에 직접 날려서 삭제하는 줄로 알았더니 위와 같이 작성하면 데이터를 모두 조회한 다음에 delete 쿼리를 일일이 날림! 즉 메모리에 대용량 데이터를 불러오니깐 oom이 발생하는 것.

(물론 db에 쿼리를 직접 날려도 지금 생각해보면 문제가 될 듯)

3. 해결방법

querydsl 벌크쿼리로 삭제!

만 건씩 id를 조회한 다음에 삭제 -> 쿼리를 날리고 영속성 컨텍스트 초기화 반복

중간중간에 영속성 컨텍스트를 비워주지 않으면 또 메모리에 과부화가 갈 수도 있으니 .clear()를 호출해주었음.

// CustomApiLogRepositoryImpl
@Override
public void deleteBatch(LocalDateTime localDateTime) {
    while (true) {
        List<Long> ids = queryFactory
                .select(apiLog.sn)
                .from(apiLog)
                .where(apiLog.registrationDate.lt(localDateTime))
                .limit(10000)
                .fetch();
        if (ids.isEmpty()) {
            break;
        }
        queryFactory
                .delete(apiLog)
                .where(apiLog.sn.in(ids))
                .execute();
        entityManager.flush();
        entityManager.clear();
    }
}

내가 일하는 곳의 도메인은 도서관이라 트래픽이 많지 않다. 그래서 oom이 발생할 거라고는 생각을 못했었는데, 이번 잘못으로 대충 코드를 작성하는 일이 없도록 노력해야겠다.

[React Native] 환경 구축,The emulator process for AVD has terminated 해결 방법

나는시화 — Wed, 5 Feb 2025 22:57:52 +0900

1.Node.js 설치

https://nodejs.org/ko

Node.js — 어디서든 JavaScript를 실행하세요

Node.js® is a JavaScript runtime built on Chrome's V8 JavaScript engine.

nodejs.org

2. Chocolatey 설치

https://chocolatey.org/install

Installing Chocolatey

Chocolatey is software management automation for Windows that wraps installers, executables, zips, and scripts into compiled packages. Chocolatey integrates w/SCCM, Puppet, Chef, etc. Chocolatey is trusted by businesses to manage software deployments.

chocolatey.org

저 부분을 복사한 뒤 PowerShell을 관리자 권한으로 실행한 다음 입력해준다.

이미지처럼 버전이 나와야함.

3. Android Studio 설치

https://developer.android.com/studio?hl=ko

Android 스튜디오 및 앱 도구 다운로드 - Android 개발자 | Android Studio | Android Developers

Android Studio provides app builders with an integrated development environment (IDE) optimized for Android apps. Download Android Studio today.

developer.android.com

1) 설치 후 안드로이드 스튜디오 실행.

2) virtual Device Manager 클릭 후 Pixel 5 선택.

3) 34, 33 모두 설치

4) SDK Manager 설치

안드로이드 13, 14, 15 설치를 했으며 모두 이미지와 같이 체크함.

우측 하단에 Show Package Details를 누르면 이미지처럼 체크박스 선택이 가능.

5) SDK Tools

4. openjdk 설치 (17 권장)

https://reactnative.dev/docs/set-up-your-environment

Set Up Your Environment · React Native

In this guide, you'll learn how to set up your environment, so that you can run your project with Android Studio and Xcode. This will allow you to develop with Android emulators and iOS simulators, build your app locally, and more.

reactnative.dev

PowerShell를 관리자 권한으로 실행한 뒤 입력

5. React Native 설치

https://reactnative.dev/docs/getting-started-without-a-framework

Get Started Without a Framework · React Native

If you have constraints that are not served well by a Framework, or you prefer to write your own Framework, you can create a React Native app without using a Framework.

reactnative.dev

6. 안드로이드 스튜디오 환경변수 설정

환경변수 > 새로만들기 > 변수이름에 ANDROID_HOME

C:\Users\${사용자이름}\AppData\Local\Android\Sdk

Path > 편집 > %ANDROID_HOME%\platform-tools 추가

참고로 시스템 변수에다가 등록하는 것이 아닌, 사용자 변수에 추가해야함.

주의사항

사용자 이름이 한글인 경우 (예를 들어서 C:\Users\홍길동\AppData\Local\Android\Sdk 이렇게 돼있을 경우 에뮬레이터 실행이 안 되는 오류가 발생함.

npx react-native run-android 를 입력해도 실행이 안 되고, 안드로이드 스튜디오에서 직접 실행해도 안 되는 경우가 있음. ( The emulator process for AVD has terminated 오류 발생)

따라서 사용자 이름을 영어로 바꾸고, 폴더명도 레지스트를 수정해서 영어로 바꿔주어야함.

[axios] 인터셉터(intercepter)

나는시화 — Tue, 7 Jan 2025 22:06:48 +0900

사용한 프레임워크:

axios, react-cookie

1. 왜 사용했는지?

만료시간이 다 된 토큰을 사용했을 때, 자동으로 represh token으로 access token을 재발급 받기 위해서 사용함.

토큰은 cookie에 담아서 사용하기 때문에 react-cookie를 사용함.

인터셉터(Interceptor)란? 요청(Request) 또는 응답(Response)이 애플리케이션에서 처리되기 전에 가로채어 특정 작업을 수행할 수 있도록 해주는 중간 처리 메커니즘

2. 사용 방법

2-1 먼저 cookie를 전역에서 사용하기 위해 최상위 컴포넌트에 <CookiesProvider>를 감싸준다.

// App.tsx
useAxiosInterceptor();
return (
    <>
        <CookiesProvider>
            <Routes>
                <Route element={<MainContent/>}>
                    <Route path={MAIN_PATH()} element={<Main/>}/>
                    <Route path={SIGNUP_PATH()} element={<SignUp/>}/>
                    <Route path={LOGIN_PATH()} element={<Login/>}/>
                    <Route path={TEST_PATH()} element={<Test/>}/>
                    <Route path={CATEGORY_PATH()} element={<Category/>}/>
                </Route>
            </Routes>
        </CookiesProvider>
    </>
);

2-2 useAxiosIntercepter.tsx 작성

import React from 'react';
import axios from 'axios';
import { useCookies } from 'react-cookie';
import {LOGIN_PATH} from "../constant";

const API_DOMAIN = process.env.REACT_APP_SERVER_DOMAIN + "/api";

// 커스텀 훅으로 인터셉터 관리
export const useAxiosInterceptor = () => {
    const [cookies, setCookie, removeCookie] = useCookies(['accessToken', 'refreshToken']);
    React.useEffect(() => {
        // 요청 인터셉터
        // const requestInterceptor = axios.interceptors.request.use(
        //     (config) => {
        //         const accessToken = cookies.accessToken;
        //         console.log(cookies);
        //         debugger;
        //         if (accessToken) {
        //             config.headers.Authorization = `Bearer ${accessToken}`;
        //         }
        //         return config;
        //     },
        //     (error) => Promise.reject(error)
        // );

        // 응답 인터셉터
        const responseInterceptor = axios.interceptors.response.use(
            (response) => response,
            async (error) => {
                const originalRequest = error.config;
                if (error.response?.status === 401 && !originalRequest._retry && error.response?.data.code === 'EJT') {
                    originalRequest._retry = true;

                    try {
                        if (!cookies.refreshToken) {
                            console.log("refreshToken이 없습니다.");
                            return;
                        }
                        const refreshToken = cookies.refreshToken;
                        const response = await axios.post(`${API_DOMAIN}/auth/refresh`, { refreshToken });

                        const { accessToken, refreshToken: newRefreshToken, accessTokenExpiredMs, refreshTokenExpiredMs } = response.data;

                        const now = new Date().getTime();
                        const accessTokenExpires = new Date(now + accessTokenExpiredMs);
                        const refreshTokenExpires = new Date(now + refreshTokenExpiredMs);
                        // 새 토큰들 쿠키에 설정
                        setCookie('accessToken', accessToken, {
                            path: '/',
                            expires: accessTokenExpires
                        });

                        if (newRefreshToken) {
                            setCookie('refreshToken', newRefreshToken, {
                                path: '/',
                                expires: refreshTokenExpires
                                // 리프레시 토큰 만료 시간 설정
                            });
                        }

                        // 원래 요청 재시도
                        originalRequest.headers.Authorization = `Bearer ${accessToken}`;
                        return axios(originalRequest);
                    } catch (refreshError) {
                        // 토큰 갱신 실패 시 로그아웃 처리
                        removeCookie('accessToken');
                        removeCookie('refreshToken');

                        // 로그인 페이지로 리다이렉트 등 추가 처리
                        window.location.href = LOGIN_PATH();

                        return Promise.reject(refreshError);
                    }
                }

                return Promise.reject(error);
            }
        );

        // 클린업 함수: 컴포넌트 언마운트 시 인터셉터 제거
        return () => {
            // axios.interceptors.request.eject(requestInterceptor);
            axios.interceptors.response.eject(responseInterceptor);
        };
    }, [cookies.accessToken, cookies.refreshToken, setCookie, removeCookie]);
};

API 서버에서 만료된 토큰일 경우 401 응답 값과 EJT 에러 코드를 반환을 했으며, 다시 요청하지 않았을 경우에만 ${API_DOMAIN}/auth/refresh에 refreshToken을 보내서 accessToken을 요청

if (error.response?.status === 401 && !originalRequest._retry && error.response?.data.code === 'EJT') {

// 재귀요청 방지
originalRequest._retry = true

// refreshToken이 없으면 요청X
if (!cookies.refreshToken) {
    console.log("refreshToken이 없습니다.");
    return;
}

// accessToken이 필요한 api를 호출하니깐 원래 요청을 다시 요청할 때 header에 accessToken을 담아서 요청
originalRequest.headers.Authorization = `Bearer ${accessToken}`;
return axios(originalRequest); // 원래 요청 재시도

현재는 response 인터셉터만 필요하기 때문에 해당 내용만 정리.

request는 필요하면 나중에 추가 정리.

[JWT] JwtProvider

나는시화 — Thu, 21 Nov 2024 21:06:42 +0900

이전 글: https://im-diary.tistory.com/120

[JWT] JwtFilter

이전 글: https://im-diary.tistory.com/119 [JWT] Security Config 6.x.xcommon/config/WebSecurityConfig.java (전체코드)@Configuration@EnableWebSecurity@RequiredArgsConstructorpublic class WebSecurityConfig { private final JwtAuthenticationFilter jwtAu

im-diary.tistory.com

생성자

Keys.hmacShaKeyFor(secret.getBytes())

secret 문자열을 바이트 배열로 변환한 후, hmacShaKeyFor 메서드를 사용하여 HMAC-SHA 알고리즘용 비밀키 객체를 생성
**Keys.hmacShaKeyFor**는 io.jsonwebtoken.security.Keys 클래스의 메서드로, JWT 서명에 사용되는 SecretKey 객체를 생성
- 이 SecretKey 객체는 JWT의 서명을 생성하거나 검증할 때 사용
- 이 과정에서 사용하는 키는 반드시 HMAC-SHA 알고리즘이 요구하는 최소 길이를 만족해야 합니다. 예를 들어, HMAC-SHA256의 경우 최소 256비트(32바이트)가 필요

@Component
public class JwtProvider {


    public SecretKey secretKey;

    public JwtProvider(@Value("${jwt.secretKey}") String secret) {
        secretKey = Keys.hmacShaKeyFor(secret.getBytes());
    }

create (토큰생성)

위에서 만들어둔 SecretKey를 사용해서 토큰을 생성
아래 코드의 주석 참고
.claims(): Map으로 여러 값 셋팅 가능 / claim(): 단일 값

public String create(String email, String role) {
    Date expiredDate = Date.from(Instant.now().plus(1, ChronoUnit.HOURS)); // 엑세스 토큰 유효시간 1시간
    Map<String, String> claimsMap = Map.of("email", email, "role", role);
    return Jwts.builder()
            .claims(claimsMap) // jwt 토큰 내 정보
            .expiration(expiredDate) // 만료시간
            .signWith(secretKey) // 암호화
            .issuedAt(Date.from(Instant.now())) // 발급 시간
            .subject("주제") // 토큰과 관련된 주요 대상  
            .compact();
}

토큰에서 값 가져오기 및 검증

public String getEmail(String jwt) { // JWT 토큰의 유효성 검사
    Claims claims = validateToken().parseSignedClaims(jwt).getPayload();
    return claims.get("email", String.class);
}

public String getRole(String jwt) { // JWT 토큰의 유효성 검사
    Claims claims = validateToken().parseSignedClaims(jwt).getPayload();
    return claims.get("role", String.class);
}

private JwtParser validateToken() {
    try{
        return Jwts.parser().verifyWith(secretKey).build();
    } catch (SecurityException | MalformedJwtException e) {
        // 서명 검증 실패 시 처리
        throw new IllegalArgumentException("Invalid JWT signature", e);
    } catch (ExpiredJwtException e) {
        // JWT가 만료된 경우 처리
        throw new IllegalArgumentException("Expired JWT token", e);
    } catch (Exception e) {
        // 기타 예외 처리
        throw new IllegalArgumentException("Invalid JWT token", e);
    }
}

전체코드

package com.my.cook_recipe.common.provider;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.Map;

@Component
public class JwtProvider {


    public SecretKey secretKey;

    public JwtProvider(@Value("${jwt.secretKey}") String secret) {
        secretKey = Keys.hmacShaKeyFor(secret.getBytes());
    }

    public String create(String email, String role) {
        Date expiredDate = Date.from(Instant.now().plus(1, ChronoUnit.HOURS)); // 엑세스 토큰 유효시간 1시간
        Map<String, String> claimsMap = Map.of("email", email, "role", role);
        return Jwts.builder()
                .claims(claimsMap) // jwt 토큰 내 정보
                .expiration(expiredDate) // 만료시간
                .signWith(secretKey) // 암호화
                .compact();
    }

    public String getEmail(String jwt) { // JWT 토큰의 유효성 검사
        Claims claims = validateToken().parseSignedClaims(jwt).getPayload();
        return claims.get("email", String.class);
    }

    public String getRole(String jwt) { // JWT 토큰의 유효성 검사
        Claims claims = validateToken().parseSignedClaims(jwt).getPayload();
        return claims.get("role", String.class);
    }

    private JwtParser validateToken() {
        try{
            return Jwts.parser().verifyWith(secretKey).build();
        } catch (SecurityException | MalformedJwtException e) {
            // 서명 검증 실패 시 처리
            throw new IllegalArgumentException("Invalid JWT signature", e);
        } catch (ExpiredJwtException e) {
            // JWT가 만료된 경우 처리
            throw new IllegalArgumentException("Expired JWT token", e);
        } catch (Exception e) {
            // 기타 예외 처리
            throw new IllegalArgumentException("Invalid JWT token", e);
        }
    }


}

기본적인 시큐리티 공부 끝 !

[JWT] JwtFilter

나는시화 — Wed, 20 Nov 2024 23:33:13 +0900

이전 글: https://im-diary.tistory.com/119

[JWT] Security Config 6.x.x

common/config/WebSecurityConfig.java (전체코드)@Configuration@EnableWebSecurity@RequiredArgsConstructorpublic class WebSecurityConfig { private final JwtAuthenticationFilter jwtAuthenticationFilter; @Bean public BCryptPasswordEncoder bCryptPasswordEnco

im-diary.tistory.com

jwtAuthenticationFilter

JwtAuthenticationFilter는 JWT(JSON Web Token)를 사용한 인증을 처리하는 필터이다. 이 필터는 스프링 시큐리티의 필터 체인에서 동작하며, 클라이언트가 보낸 JWT 토큰을 검증하고 인증 정보를 설정하는 역할을 한다.

주요 역할:

JWT 추출: 요청의 헤더에서 JWT 토큰을 추출한다. 일반적으로 Authorization 헤더에 "Bearer <token>" 형태로 JWT가 포함된다.
JWT 검증: 추출한 JWT 토큰을 서버에서 사용 가능한 비밀 키를 통해 검증한다. 검증에 성공하면 해당 토큰에 포함된 사용자 정보를 추출할 수 있다.
Authentication 설정: 토큰이 유효하면, JWT에 포함된 사용자 정보(예: 사용자 이름, 권한 등)를 바탕으로 Authentication 객체를 생성하고, 이를 스프링 시큐리티의 SecurityContext에 설정하여 인증된 사용자로 처리한다.
인증 실패 시 처리: JWT가 유효하지 않거나 만료된 경우, 예외를 던지거나 적절한 오류 응답을 반환한다.
- 예외는 exceptionHandling에서 처리한다.

JwtAuthenticationFilter 전체 코드

OncePerRequestFilter를 상속받은 JwtAuthenticationFilter의 doFilterInternal 메서드를 실행

package com.my.cook_recipe.common.filter;

import com.my.cook_recipe.common.provider.JwtProvider;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;
import java.util.Collections;

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final JwtProvider jwtProvider;


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        try{
            String token = parseBearerToken(request);
            if(token==null){
                filterChain.doFilter(request,response);
                return;
            }
            String email = jwtProvider.getEmail(token);
            if(email == null){
                filterChain.doFilter(request,response);
                return;
            }
            String role = jwtProvider.getRole(token);

            /*             // 권한부여X           */
//            AbstractAuthenticationToken authenticationToken =
//                    new UsernamePasswordAuthenticationToken(email,null, AuthorityUtils.NO_AUTHORITIES);

            /*          // 권한 여러개 부여    */
//            AbstractAuthenticationToken authenticationToken =
//                    new UsernamePasswordAuthenticationToken(email, null, Arrays.asList(new SimpleGrantedAuthority("ROLE_" + role),new SimpleGrantedAuthority("ROLE_" + role) ));

            AbstractAuthenticationToken authenticationToken =
                    new UsernamePasswordAuthenticationToken(email, null, Collections.singletonList(new SimpleGrantedAuthority("ROLE_" + role))); // 권한 부여

            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContext context = SecurityContextHolder.getContext();
            context.setAuthentication(authenticationToken);
//            SecurityContext securityContext = SecurityContextHolder.createEmptyContext(); // 새로운 빈 보안 컨텍스트 생성
//            securityContext.setAuthentication(authenticationToken); // 앞서 생성한 인증 토큰을 보안 컨텍스트에 설정
        }catch (Exception e){
            e.printStackTrace();
        }
        filterChain.doFilter(request,response);
    }

    private String parseBearerToken(HttpServletRequest request){
        String authorization = request.getHeader("Authorization");
        boolean hasAuthorization = StringUtils.hasText(authorization);
        if(!hasAuthorization) return null;

        boolean isBearer = authorization.startsWith("Bearer "); // "Bearer " 로 시작하느냐?
        if(!isBearer) return null;
        String token = authorization.substring(7);
        return token;
    }
}

parseBearerToken(HttpServletRequest request) // 토큰을 가져오는 메서드

private String parseBearerToken(HttpServletRequest request){
    String authorization = request.getHeader("Authorization");
    boolean hasAuthorization = StringUtils.hasText(authorization);
    if(!hasAuthorization) return null;

    boolean isBearer = authorization.startsWith("Bearer "); // "Bearer " 로 시작하느냐?
    if(!isBearer) return null;
    String token = authorization.substring(7);
    return token;
}

String authorization = request.getHeader("Authorization");
boolean hasAuthorization = StringUtils.hasText(authorization); => 헤더에 Authorization이 있는 지 확인한다.
boolean isBearer = authorization.startsWith("Bearer "); // "Bearer " 로 시작하느냐?
if(!isBearer) return null;
String token = authorization.substring(7);
return token; => 토큰 반환

나머지 간단한 설명

jwtProvider.getEmail(), .getRole()
- 토큰에서 email과 role을 가져오는 메서드
AbstractAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(email, null, Collections.singletonList(new SimpleGrantedAuthority("ROLE_" + role)));
- 권한 부여
- "ROLE_"을 꼭 붙여주어야함.
- SecurityConfig -> .requestMatchers().hasRole(); 이 때 사용함. (뒤에 자세히 설명)
SecurityContext context = SecurityContextHolder.getContext();
authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
context.setAuthentication(authenticationToken);
- authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
  - setDetails() 메서드는 Authentication 객체의 세부 정보를 설정하는 데 사용. 여기서 설정된 세부 정보는 주로 웹 요청에 대한 추가적인 정보를 포함. WebAuthenticationDetailsSource는 이러한 세부 정보를 생성하는 역할
- context.setAuthentication(authenticationToken);
  - 인증 정보를 담아줌.

            String email = jwtProvider.getEmail(token);
            if(email == null){
                filterChain.doFilter(request,response);
                return;
            }
            String role = jwtProvider.getRole(token);

            /*             // 권한부여X           */
//            AbstractAuthenticationToken authenticationToken =
//                    new UsernamePasswordAuthenticationToken(email,null, AuthorityUtils.NO_AUTHORITIES);

            /*          // 권한 여러개 부여    */
//            AbstractAuthenticationToken authenticationToken =
//                    new UsernamePasswordAuthenticationToken(email, null, Arrays.asList(new SimpleGrantedAuthority("ROLE_" + role),new SimpleGrantedAuthority("ROLE_" + role) ));

            AbstractAuthenticationToken authenticationToken =
                    new UsernamePasswordAuthenticationToken(email, null, Collections.singletonList(new SimpleGrantedAuthority("ROLE_" + role))); // 권한 부여
            SecurityContext context = SecurityContextHolder.getContext();
            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            context.setAuthentication(authenticationToken);

실제 사용

1. 테스트를 위해 로그인 기능 없이 토큰을 생성해서 클라이언트로 보내줌

package com.my.cook_recipe;

import com.my.cook_recipe.common.provider.JwtProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class MainController {

    private final JwtProvider jwtProvider;

    @GetMapping("/")
    public ResponseEntity<String> mainView(){
        String token = jwtProvider.create("test@naver.com", "USER");
        return ResponseEntity.ok(token);
    }
}

2. 해당 토큰을 헤더에 넣어서 서버로 요청

2-1 현재 "/api/user/**"는 "USER" 권한을 가진 토큰만 접근을 허용시켜줌.

.requestMatchers("/api/user/**").hasRole("USER")

2-2 내부 로직을 보면 JwtAuthenticationFilter의 doFilterInternal로 필터가 먼저 적용됨.

토큰에서 "role" 값을 꺼낸 뒤 아래 이미지처럼 권한을 부여해줌.

2-3 현재 권한은 "USER"로, hasRole의 권한과 일치하기 때문에 접근이 가능함.

2-4 만약 일치하지 않으면? 예외가 발생해서 exceptionHandling이 작동하게 됨.

내일 정리할 내용:

jwtProvider

[JWT] Security Config 6.x.x

나는시화 — Tue, 19 Nov 2024 21:46:38 +0900

common/config/WebSecurityConfig.java (전체코드)

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig {

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }


    @Bean
    protected SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                .cors(cors -> cors.configurationSource(corsConfigrationSourse()))
                .csrf(CsrfConfigurer::disable) // csrf disable
                .httpBasic(HttpBasicConfigurer::disable) // http basic 인증 방식 disable
                .formLogin(FormLoginConfigurer::disable) // form 로그인 방식 disable
                .sessionManagement(sessionManagement -> sessionManagement
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                ).authorizeHttpRequests(request -> request
                                .requestMatchers("/", "/user/*", "/css/**","/js/**").permitAll() // permitAll():  모든 권한 허용
                                .requestMatchers(HttpMethod.POST, "/api/user/**").permitAll()
                                .requestMatchers(HttpMethod.GET, "/api/board/**", "/api/user/**").permitAll()
                                .anyRequest().authenticated()
                ).exceptionHandling(exceptionHandling -> exceptionHandling.authenticationEntryPoint(new FailedAuthenticationEntryPoint()))
                        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        return httpSecurity.build();
    }

    @Bean
    protected CorsConfigurationSource corsConfigrationSourse() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET","POST","PUT","DELETE","PATCH"));
        configuration.setAllowedHeaders(Arrays.asList("X-Requested-With", "Content-Type", "Authorization", "X-XSRF-token"));
        configuration.setAllowCredentials(false);
        configuration.setMaxAge(3600L);
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}
class FailedAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("{\"code:\": \"AF\", \"message\": \"Authorization Failed.\"}");
    }
}

1. httpSecurity.cors()

1.1) CORS(Cross-Origin Resource Sharing) 설정

다른 도메인에서 API를 호출할 때 허용 여부를 제어하는 규칙을 설정

configuration.setAllowedOrigins(Arrays.asList("*"))
- 모든 도메인에서의 요청을 허용
configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "PATCH"))
- 허용하는 메서드
configuration.setAllowedHeaders(Arrays.asList("X-Requested-With", "Content-Type", "Authorization", "X-XSRF-token"))
- 클라이언트가 보낼 수 있는 요청 헤더를 지정
- 주로 인증에 필요한 Authorization 헤더 등을 포함
configuration.setAllowCredentials(false) (링크O)
- 쿠키를 포함한 자격 증명을 허용하지 않도록 설정
configuration.setMaxAge(3600L)
- 캐싱 가능한 시간(초)을 설정. 3600초(1시간) 동안 CORS 결과를 캐시.
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
- 모든 URL 경로에 대해 위의 CORS 설정을 적용

@Bean
protected CorsConfigurationSource corsConfigrationSourse() {
    CorsConfiguration configuration = new CorsConfiguration();
    configuration.setAllowedOrigins(Arrays.asList("*"));
    configuration.setAllowedMethods(Arrays.asList("GET","POST","PUT","DELETE","PATCH"));
    configuration.setAllowedHeaders(Arrays.asList("X-Requested-With", "Content-Type", "Authorization", "X-XSRF-token"));
    configuration.setAllowCredentials(false);
    configuration.setMaxAge(3600L);
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", configuration);
    return source;
}

2. CSRF

CSRF는 사용자가 인증된 상태에서 악의적인 웹사이트가 사용자를 대신해 요청을 보내는 공격

공격자가 사용자의 쿠키를 이용해 사용자의 권한으로 서버에 요청을 보냄
주로 쿠키 기반 인증에서 문제가 발생
(예: 세션 ID가 쿠키에 저장된 상태에서 쿠키가 자동으로 서버에 전송되는 상황)

2.1) JWT와 CSRF

JWT는 클라이언트가 명시적으로 헤더에 추가해야 서버가 인증 요청을 처리
CSRF는 서버가 쿠키를 자동으로 전송하는 점을 악용하는 공격인데, JWT는 쿠키를 사용하지 않아 이러한 취약점에서 자유롭다.

JWT 인증은 쿠키가 아닌 HTTP 헤더(주로 Authorization: Bearer <JWT> 헤더)를 통해 토큰을 전송하기 때문에 CSRF 공격이 어렵다.

2.3) 왜 CSRF를 disable해야 하는가?

CSRF 방어는 쿠키를 기반으로 동작

Spring Security는 기본적으로 CSRF 보호를 활성화하며, 이를 위해 CSRF 토큰을 쿠키로 전달하고 확인
그러나 JWT 방식은 쿠키 기반 세션 관리가 아닌, stateless(상태를 저장하지 않는) 방식으로 동작.
따라서 CSRF 보호를 유지하면 불필요한 오버헤드가 생기고, JWT 인증 로직에 혼란을 줄 수 있음

4. Stateless 환경에서 CSRF 방어가 불필요한 이유

JWT 인증 방식에서는 서버가 클라이언트의 상태를 유지 X
즉, 세션이 없으므로 CSRF 토큰을 검증할 서버 측 데이터가 없음
또한, CSRF 공격은 사용자가 신뢰하지 않는 사이트를 방문하여 발생하므로, CORS 정책과 함께 사용하면 추가적인 방어가 가능

3. httpBasic (HttpBasicConfigurer::disable)

HTTP Basic 인증 방식 비활성화:
- HTTP Basic은 사용자 이름과 비밀번호를 HTTP 요청 헤더에 포함시켜 인증하는 방식
- 이 코드는 Basic 인증 대신 JWT를 사용하기 때문에 이를 비활성화

4. formLogin(FormLoginConfigurer::disable)

폼 로그인 방식 비활성화:

Spring Security에서 제공하는 기본 로그인 페이지와 로그인 처리를 비활성화
JWT 기반 인증에서는 클라이언트가 직접 로그인 요청을 처리하고, 토큰을 발급받으므로 필요 없음

5. sessionManagement(sessionManagement -> sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS))

세션 정책 설정:

SessionCreationPolicy.STATELESS: 서버가 사용자의 세션을 관리하지 않도록 설정
JWT는 상태를 유지하지 않는(stateless) 방식으로 동작하므로, 세션을 사용하지 않음

6. authorizeHttpRequests

authenticated(): 인증된 사용자만 접근을 허용
fullyAuthenticated(): 완전히 인증된 사용자만 접근을 허용
hasRole(String role): 특정 역할을 가진 사용자만 접근을 허용
hasAnyRole(String... roles): 주어진 역할 중 하나라도 가진 사용자만 접근을 허용
hasAuthority(String authority): 특정 권한을 가진 사용자만 접근을 허용
hasAnyAuthority(String... authorities): 주어진 권한 중 하나라도 가진 사용자만 접근을 허용
denyAll(): 모든 접근을 거부
anonymous(): 익명 사용자만 접근을 허용
rememberMe(): "Remember Me" 인증을 통해 인증된 사용자만 접근을 허용

.authorizeHttpRequests(request -> request
                .requestMatchers("/", "/user/*", "/css/**","/js/**").permitAll() // permitAll():  모든 권한 허용
                .requestMatchers(HttpMethod.POST, "/api/user/**").permitAll()
                .requestMatchers(HttpMethod.GET, "/api/board/**", "/api/user/**").hasAnyRole("ADMIN", "USER")
                .anyRequest().authenticated()

7. exceptionHandling

인증 실패 시 동작을 정의함
- authenticationEntryPoint(new FailedAuthenticationEntryPoint())
  - 인증 실패 시 커스텀한 동작을 수행하도록 설정.
  - 아래 코드를 예로 들어서 설명하자면, 허용되지 않은 url로 접근을 하거나, 인증이 실패한 경우 "application/json" 타입으로 401 코드와 같이 이미지와 같은 메시지를 출력해줌.

class FailedAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("{\"code:\": \"AF\", \"message\": \"Authorization Failed.\"}");
    }

8. addFilterBefore

JWT 인증 필터를 Spring Security 필터 체인에 추가

UsernamePasswordAuthenticationFilter 앞에 jwtAuthenticationFilter를 추가하여 JWT 인증을 처리하도록 설정.

[JWT] 프로젝트 생성1

나는시화 — Mon, 18 Nov 2024 21:17:46 +0900

필수 의존성

Spring Web
Spring Security
Spring Data JPA
DB Driver (Maria DB Driver)

JWT 필수 의존성

JWT 토큰을 생성, 관리를 위해 JWT 의존성을 필수로 설정해야 함.

현재 최신 버전은 0.12.6

https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt-api/0.12.6

// build.gradle
dependencies {
    implementation 'io.jsonwebtoken:jjwt-api:0.12.6'
    implementation 'io.jsonwebtoken:jjwt-impl:0.12.6'
    implementation 'io.jsonwebtoken:jjwt-jackson:0.12.6'
}

[오류] 배포 중 로DB 접근 관련 오류

나는시화 — Wed, 11 Sep 2024 23:07:02 +0900

1. 오류 내용

배포 관련 공부를 진행하던 중 오류가 발생함.

java.sql.SQLNonTransientConnectionException: Socket fail to connect to host:address=(host=172.30.1.32)(port=3307)(type=primary). Connect timed out

DB에 연결에 실패했다는 로그가 찍힌 것을 보고 문제 해결에 나섬.

현재 DB 서버는 어떻게 해야할 지 고민이라, 현재 사용하고 있는 컴퓨터에 DB를 설치 후 개방해서 임시로 사용하기로 정함.

2. 해결 과정

1) 방화벽 포트를 개방해줌.

여기서 이바운드 규칙이란?

외부에서 내 컴퓨터로 접근할 수 있는 규칙을 의미함.

2) 포트포워딩

주소창에 172.30.1.254를 입력 후 포트 포워딩 설정을 해주었음. (kt 기준)

3) DB 계정을 외부에서 접근이 가능하도록 권한 설정

계정 생성
- userid : 생성할 ID를 의미
- % : 허용 위치를 적어주면 됨. %는 모든 접근을 허용하겠다는 의미
- 'password' : 비밀번호 설정

CREATE USER 'userid'@'%' IDENTIFIED BY 'password';

확인

USE mysql;
CREATE USER 'userid'@'%' IDENTIFIED BY 'password';

3. 결과

맨날 코드만 작성했 지 이런 환경 셋팅같은 건 처음 해봐서 많이 헤맸었다.

그대로 혼자 하나 씩 문제를 해결해 나가는 과정이 재밌기도 했으며, 성취감이 있었다.

공부한 내용들을 까먹지 않기 위해서 정리를 해야하는데 생각보다 쉽지가 않다..

앞으로의 계획:

1. 이번에 했던 DB 관련된 내용 정리하기.

2. 로그 모니터링 기능 개발

3. 프론트 배포 방법 공부 및 정리

4. 자료구조, 알고리즘 공부 및 정리

할 수 있다!!! 화이팅~~~~~~~~~