수테크📱⌚️👀

문제 😵‍💫

https://school.programmers.co.kr/learn/courses/30/lessons/43165

내 풀🦷

class Solution {
    public int solution(int[] numbers, int target) {
        return dfs(numbers, target, 0, 0);
    }
    
    private int dfs(int[] numbers, int target, int index, int sum) {
        // 모든 숫자를 다 사용했을 떄
        if(index == numbers.length) {
            // 목표 숫자와 합이 같으면 경우의 수 1 증가
            return sum == target ? 1 : 0;
        }
        // 현재 숫자를 더하는 경우와 빼는 경우로 재귀 호충..
        return dfs(numbers, target, index + 1, sum + numbers[index]) + dfs(numbers, target, index + 1, sum - numbers[index]);
    }
}

이미 한번 풀었던 dfs 문제!!

모든 가능한 경로를 다 탐색하여 특정 조건을 찾아야하는 문제이므로 dfs를 사용하였다

if문을 쓰는것까지는 쉬운데 마지막에 재귀를 어떻게 시켜야하는지는 항상 고민되는 부분인거 같다..

하지만 이번문제는 수월하게 통과~~

참고하면 좋을 개념들 ✍️

 DFS를 사용했을 때 효과적인 문제 유형

1. 모든 경로를 탐색하여 특정 조건을 찾는 경우 : 주어진 숫자 배열을 더하고 빼서 특정 값을 만드는 문제
2. 해다 존재하는지 확인하는 경우 : 미로에서 출구까지 가는 경로가 있는지 확인할 때
3. 조합과 순열을 생성하는 문제 : 특정 길이의 조합을 생성하거나, 순열을 만드는 문제
4. 백트래킹과 함께 사용할 때 : N-Queens 문제처럼 제한 조건을 만족하는 경우의 수를 찾을 때

DFS 사용 시 주의사항

- 무한 루프 주의 : 재귀 호출에서 종료 조건을 명확히 설정해야 합니다

- 메모리 사용량 : 깊이가 깊어질 경우 메모리 사용량이 커질 수 있으므로, 너무 깊은 재귀 호출이 필요한 문제에서는 스택 오버플로우에 주의해야 합니다

- 탐색 최적화 : 백트래킹을 사용하여 불필요한 경로는 조기에 중단하여 효율성을 높일 수 있습니다

문제 😵‍💫

https://school.programmers.co.kr/learn/courses/30/lessons/42748

내 풀🦷

import java.util.*;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];
        
        for(int i = 0; i < commands.length; i++) { 
            int start = commands[i][0] -1;
            int end = commands[i][1];
            int k = commands[i][2] - 1;
            
            // 배열의 특정 구간을 복사하고 정렬
            int[] arr = Arrays.copyOfRange(array, start, end);
            Arrays.sort(arr);
            
            // k번째 숫자를 결과 배열에 추가
            answer[i] = arr[k];
            
            }
        return answer;
    }
}

오랜만에 풀어보는 정렬문제라 간단한 문제지만 당황했다 ㅎㅎ

어떻게 배열을 가져오는것이 좋을지 for문 돌면서 새로운 배열을 만들어서 넣어줄까했는데 찾아보니 copyOfRange라는 배열 복사 메서드가 존재하여 사용해서 쓰니까 금방 해결 !!!

copyOfRange 꼭 기억해 두겠음~

참고하면 좋을 개념들 ✍️

Arrays.copyOfRange(원본배열, 시작인덱스, 끝인덱스);

원본배열 : 복사하려는 배열
시작 인덱스 : 복사를 시작할 인덱스(포함)
끝인덱스 : 복사를 종료할 인덱스(미포함)

int[] array = {1, 5, 2, 6, 3, 7, 4};
int[] slicedArray = Arrays.copyOfRange(array, 1, 5); // {5, 2, 6, 3}

# 1. 음성 파일 변환에 필요한 ffmpeg 다운 받기!

https://yeko90.tistory.com/entry/FFmpeg-%EB%8B%A4%EC%9A%B4%EB%A1%9C%EB%93%9C-%EC%84%A4%EC%B9%98-%EC%84%B8%ED%8C%85

다운로드 하고 너무 억까 당했지만.. 컴퓨터 리부팅 해주니까 해결 ^^;;;; 완전 러키비키다

# 2. 처음 보는 에러 정리

libiomp5md.dll 파일이 여러 번 초기화되어 발생하는 오류는 OpenMP라는 병렬 컴퓨팅 라이브러리가 여러 번 로드되면서 생기는 충돌 문제입니다. 이 문제는 주로 PyTorch나 NumPy 같은 라이브러리를 사용할 때 발생할 수 있습니다. 간단히 말해서, 프로그램에서 OpenMP를 두 번 이상 불러오게 되어 충돌이 생긴 겁니다.

이 오류를 해결하려면 환경 변수를 설정하여 OpenMP가 여러 번 로드되더라도 오류가 발생하지 않도록 해야 합니다. 이를 위해 KMP_DUPLICATE_LIB_OK라는 환경 변수를 TRUE로 설정하면 됩니다.

환경 변수를 설정하는 방법 (Windows)

1. 명령 프롬프트에서 일시적으로 설정하기

이 방법은 현재 명령 프롬프트 세션에서만 환경 변수가 설정되며, 컴퓨터를 재부팅하거나 새로 명령 프롬프트를 열면 이 설정은 사라집니다.

1. 명령 프롬프트를 열고, 다음 명령어를 입력합니다:
2. bash
3. 이 상태에서 파이썬 스크립트를 실행해 오류가 해결되었는지 확인해 보세요.

set KMP_DUPLICATE_LIB_OK=TRUE

2. Python 코드 내에서 환경 변수 설정하기

Python 코드 안에서 직접 환경 변수를 설정하면, 해당 코드가 실행되는 동안만 환경 변수가 적용됩니다.

1. import 문 아래에 다음 코드를 추가합니다:
2. python
    
3. 이 코드를 추가한 후에 다시 실행해 보세요. Python이 실행되는 동안 이 환경 변수가 적용됩니다.

import os os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

3. 시스템 환경 변수로 영구 설정하기 (Windows)

이 방법은 컴퓨터의 환경 변수에 KMP_DUPLICATE_LIB_OK를 추가하여, 모든 명령 프롬프트와 프로그램에서 이 설정이 유지되도록 합니다.

1. Windows 검색창에 "환경 변수 편집"이라고 입력하고 시스템 환경 변수 편집을 선택합니다.
2. 환경 변수 창에서 아래 단계를 따릅니다:
   • 시스템 변수 부분에서 "새로 만들기" 버튼을 클릭합니다.
   • 변수 이름에 KMP_DUPLICATE_LIB_OK을 입력합니다.
   • 변수 값에 TRUE를 입력합니다.
3. 확인을 눌러 모든 창을 닫고 컴퓨터를 재부팅하면, 이 설정이 모든 명령 프롬프트와 프로그램에 적용됩니다.

# 3. MongoDB Atlas Cloud Database 설치후에 fastapi와 연결하는 코드

from pymongo.mongo_client import MongoClient
from pymongo.server_api import ServerApi
import os
from dotenv import load_dotenv
from datetime import datetime


# .env 파일 로드
load_dotenv()

uri = os.getenv("MONGO_URI")

# Create a new client and connect to the server
client = MongoClient(uri, server_api=ServerApi('1'))

# 데이터베이스 및 컬렉션 선택
db = client["maeubom"]
collection = db["maeubom"]

# 삽입할 데이터의 속성 정의
# 각 컬렉션 정의
emotion_analysis_col = db["EmotionAnalysis"]
summary_col = db["Summary"]
generated_image_col = db["GeneratedImage"]
generated_music_col = db["GeneratedMusic"]
quote_col = db["Quote"]
analysis_session_col = db["AnalysisSession"]

def get_database():
    return db

'''
# 다른 파일에서 database.py의 db 연결 가져오기
from database import get_database

db = get_database()  # 데이터베이스 객체 가져오기
collection = db["maeumbom"]  # 컬렉션 선택
'''

# 텍스트 요약 모델 사용하기 

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import nltk
from fastapi import FastAPI, Form
import torch

# NLTK 데이터 다운로드
nltk.download('punkt')

# 모델과 토크나이저 설정
model_dir = "lcw99/t5-base-korean-text-summary"
tokenizer = AutoTokenizer.from_pretrained(model_dir)
model = AutoModelForSeq2SeqLM.from_pretrained(model_dir)

# CUDA 장치 설정
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)  # 모델을 CUDA로 이동

app = FastAPI()

@app.post("/text_sum/")
async def text_sum(input_text: str = Form(...)):
    max_input_length = 512

    # 입력 텍스트 설정 및 전처리
    text = input_text
    inputs = ["summarize: " + text]
    inputs = tokenizer(inputs, max_length=max_input_length, truncation=True, return_tensors="pt").to(device)  # 입력을 CUDA로 이동

    # 요약 생성
    with torch.no_grad():
        output = model.generate(**inputs, num_beams=8, do_sample=True, min_length=10, max_length=100)

    # 요약된 텍스트 디코딩 및 문장화
    decoded_output = tokenizer.batch_decode(output, skip_special_tokens=True)[0]
    predicted_summary = nltk.sent_tokenize(decoded_output.strip())[0]

    return {"result": predicted_summary}

# 명언 추천 모델 사용 못하고 랜덤 돌리기;;;

from transformers import OPTForCausalLM, GPT2Tokenizer
from fastapi import FastAPI, Form
import torch
import random

# 모델과 토크나이저 설정
model = OPTForCausalLM.from_pretrained("facebook/opt-350m", torch_dtype=torch.float16)
tokenizer = GPT2Tokenizer.from_pretrained("facebook/opt-350m")

# 모델이 사용할 장치 설정
device = "cuda" if torch.cuda.is_available() else "cpu"
model.to(device)

# FastAPI 앱 초기화
app = FastAPI()

# 명언 파일에서 명언을 읽어 리스트에 저장
def load_quotes(file_path="wise_saying.txt"):
    with open(file_path, "r", encoding="utf-8") as file:
        return [line.strip() for line in file.readlines() if line.strip()]

quotes = load_quotes()  # wise_saying.txt에서 명언 불러오기

# FastAPI 엔드포인트: 입력한 텍스트를 기반으로 명언 생성
@app.post("/create_text/")
async def create_text(input_text: str = Form(...)):
    # 명언 리스트에서 무작위로 하나 선택
    selected_quote = random.choice(quotes)
    selected_quote = selected_quote.split('.', 1)[-1].strip()
    return {"result": selected_quote}


# # 입력 텍스트와 가장 관련 있는 명언을 찾는 함수
# def get_best_quote(input_text, quotes):
#     best_quote = ""
#     highest_score = -float("inf")  # 초기 최고 점수를 음의 무한대로 설정

#     for quote in quotes:
#         prompt = f"다음 입력 문구와 가장 잘 맞는 명언을 고르시오: '{input_text}'\n명언: '{quote}'"
        
#         # 입력 텍스트와 명언을 함께 토큰화하여 모델 입력으로 사용
#         inputs = tokenizer(prompt, return_tensors="pt").to(device)
#         with torch.no_grad():
#             # 텍스트와 명언의 관련성을 평가하도록 모델 사용
#             output = model(**inputs).logits.mean().item()
        
#         # 모델 출력이 높을수록 높은 연관성으로 간주
#         if output > highest_score:
#             highest_score = output
#             best_quote = quote

#     return best_quote

# # FastAPI 엔드포인트: 입력한 텍스트를 기반으로 가장 적합한 명언 선택
# @app.post("/create_text/")
# async def create_text(input_text: str = Form(...)):
#     # 입력 텍스트와 가장 관련 있는 명언을 찾음
#     selected_quote = get_best_quote(input_text, quotes)
#     selected_quote = selected_quote.split('.', 1)[-1].strip()
#     return {"result": selected_quote}

# 텍스트 이미지 생성 다시 해보기..

from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
from PIL import Image
import requests
import json
import torch

model_id = "CompVis/stable-diffusion-v1-4"
device = "cuda"

pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
pipe = pipe.to(device)


# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(input_text: str = Form(...)):       

    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=input_text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    # return {"image_path": image_path}
    return FileResponse(image_path, media_type="image/png")




# 시간 너무 오래 걸려서 줄이는 중...

from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
import torch

model_id = "runwayml/stable-diffusion-v1-5"
device = "cuda"

# Stable Diffusion Pipeline 설정 (FP16 사용)
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to(device)

app = FastAPI()

@app.post("/createimage/")
async def create_image(input_text: str = Form(...)):       
    # 텍스트 기반으로 이미지 생성 (속도 최적화를 위한 파라미터 조정)
    image = pipe(
        prompt=input_text,
        num_inference_steps=20,  # 생성 속도 개선을 위해 20단계로 설정
        guidance_scale=3.0       # 프롬프트 따르는 강도 조정
    ).images[0]

    # 이미지 저장 및 반환
    image_path = "generated_image.png"
    image.save(image_path)
    return FileResponse(image_path, media_type="image/png")

어제 쓴 StableDiffusion 로그인 하는 법 성범님이 알려주심...

1. token 새로 생성하고

2. 터미널에 huggingface-cli login 입력하면

3. 토큰 넣어라고 하는데... 안 보이니까 한번만 붙여넣기 하삼..

# '''
# 5. 음악, 명언, 그림 추천/생성: (모델 미정) :
#      (후보 1) facebook/musicgen-small 
#      프롬프터를 작성해주면 음악을 만들어주는 모델입니다. 
#      대신 이건 저희가 백엔드 쪽에서 프롬프터를 몇가지 만들어서 넣어줘야 할 것 같아요.
# '''


from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from PIL import Image
import torch
import json
import requests

# # Hugging Face API 토큰 설정
# API_TOKEN = "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"
# headers = {"Authorization": f"Bearer {API_TOKEN}"}

# Stable Diffusion 모델 로드
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16,
    use_auth_token=API_TOKEN  # API 토큰을 사용해 인증
)
pipe = pipe.to("cuda")

# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(text: str = Form(...)):
    """
    주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
    """
    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    return {"image_path": image_path}
    
 
 
 # 일단 수정 한번 한 이미지 생성 
 from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from fastapi.responses import FileResponse
import torch

# 호환 가능한 모델 ID를 사용하여 모델 로드
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    safety_checker=None  # 안전 검사기를 비활성화하여 일부 오류 방지
).to("cuda")
pipe.enable_attention_slicing()

# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(text: str = Form(...)):
    """
    주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
    """
    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    return FileResponse(image_path, media_type="image/png")

# 딥러닝 환경 구축 : CUDA, CuDNN

https://developer.nvidia.com/cuda-11.3.0-download-archive?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

https://developer.nvidia.com/cudnn-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exe_local

https://velog.io/@euisuk-chung/%ED%99%98%EA%B2%BD%EA%B5%AC%EC%B6%95-CUDA-CuDNN%EC%95%84-%EB%82%98-%EC%A2%80-%EA%B7%B8%EB%A7%8C-%EA%B4%B4%EB%A1%AD%ED%98%80%EB%9D%BC-%E3%85%A0

# 텍스트 -> 사진 (stabilityai/stable-diffusion-3.5-large)

가이드..

https://stabilityai.notion.site/Stable-Diffusion-3-5-Large-Fine-tuning-Tutorial-11a61cdcd1968027a15bdbd7c40be8c6

실패 코드...

# '''
# 5. 음악, 명언, 그림 추천/생성: (모델 미정) :
#      (후보 1) facebook/musicgen-small 
#      프롬프터를 작성해주면 음악을 만들어주는 모델입니다. 
#      대신 이건 저희가 백엔드 쪽에서 프롬프터를 몇가지 만들어서 넣어줘야 할 것 같아요.
# '''


from diffusers import StableDiffusionPipeline
from fastapi import FastAPI, Form
from PIL import Image
import torch
import json
import requests

# Hugging Face API 토큰 설정
API_TOKEN = "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"
headers = {"Authorization": f"Bearer {API_TOKEN}"}

# Stable Diffusion 모델 로드
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.float16,
    use_auth_token=API_TOKEN  # API 토큰을 사용해 인증
)
pipe = pipe.to("cuda")

# FastAPI 인스턴스 생성
app = FastAPI()

# 이미지 생성 엔드포인트
@app.post("/createimage/")
async def create_image(text: str = Form(...)):
    """
    주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
    """
    # 텍스트 기반으로 이미지 생성
    image = pipe(
        prompt=text,
        num_inference_steps=28,
        guidance_scale=3.5
    ).images[0]

    # 이미지 저장
    image_path = "generated_image.png"
    image.save(image_path)

    return {"image_path": image_path}



# from diffusers import BitsAndBytesConfig, StableDiffusionPipeline
# from fastapi import FastAPI, Form
# from PIL import Image
# import torch
# # from huggingface_hub import login

# # 엑세스 토큰
# # Hugging Face 로그인 (토큰 필요)
# # login("your_hugging_face_access_token")

# # 모델 설정
# model_id = "stabilityai/stable-diffusion-3.5-large, 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=access_token"
# nf4_config = BitsAndBytesConfig(
#     load_in_4bit=True,
#     bnb_4bit_quant_type="nf4",
#     bnb_4bit_compute_dtype=torch.bfloat16
# )

# # 모델 로드
# pipe = StableDiffusionPipeline.from_pretrained(
#     model_id,
#     torch_dtype=torch.bfloat16,
#     quantization_config=nf4_config
# )
# pipe = pipe.to("cuda")
# pipe.enable_model_cpu_offload()

# # FastAPI 인스턴스 생성
# app = FastAPI()


# # 이미지 생성 엔드포인트
# @app.post("/createimage/")
# async def create_image(text: str = Form(...)):
#     """
#     주어진 텍스트 프롬프트를 기반으로 이미지를 생성하여 저장합니다.
#     """
#     # 텍스트 기반으로 이미지 생성
#     image = pipe(
#         prompt=text,
#         num_inference_steps=28,
#         guidance_scale=3.5
#     ).images[0]

#     # 이미지 저장 경로
#     image_path = "generated_image.png"
#     image.save(image_path)

#     return {"image_path": image_path}

# 텍스트 -> 오디오 (facebook/musicgen-small)

from fastapi import FastAPI, Form
from transformers import pipeline, AutoProcessor, MusicgenForConditionalGeneration
import scipy.io.wavfile
import torch
import tempfile
import os
import torch
# print(torch.cuda.is_available())  # True가 출력되면 GPU를 사용할 수 있는 상태입니다.
# 모델이 GPU로 이동되었는지 확인

app = FastAPI()

# # MusicGen 모델 설정
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", torch_dtype=torch.float32).to("cuda")
print(next(model.parameters()).device)  # "cuda:0"이 출력되면 GPU에 로드된 것

# 음악 생성 파이프라인 함수
def generate_music(text: str, length: int = 512):
    # 텍스트를 모델에 입력할 수 있는 형태로 변환
    inputs = processor(text=[text], padding=True, return_tensors="pt").to("cuda")
    
    # 모델을 통해 오디오 값 생성
    audio_values = model.generate(**inputs, max_new_tokens=length)
    
    # 생성된 오디오를 WAV 파일로 임시 저장
    sampling_rate = model.config.audio_encoder.sampling_rate
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
        scipy.io.wavfile.write(tmp_file.name, rate=sampling_rate, data=audio_values[0, 0].cpu().numpy())
        temp_path = tmp_file.name
    
    return temp_path

# FastAPI 엔드포인트: 요약된 텍스트 기반으로 음악 생성
@app.post("/recommend_music/")
async def recommend_music(summary_text: str = Form(...), length: int = Form(512)):
    # 음악 생성
    music_path = generate_music(summary_text)
    
    # 생성된 음악 파일 경로 반환
    return {"music_path": music_path}

# FastAPI에서 정적 파일로 WAV 파일을 제공할 수 있도록 설정 (간단한 테스트용)
@app.get("/download_music/")
async def download_music(music_path: str):
    if os.path.exists(music_path):
        with open(music_path, "rb") as f:
            data = f.read()
        return {"audio_data": data}
    else:
        return {"error": "File not found"}

시큐리티 버전별 특성

: 스프링은 버전에 따라 구현 방식이 변경되는데 시큐리티의 경우 특히 세부 버전별로 구현 방법이 많이 다르기 때문에 버전마다 구현 특징을 확인해야 한다

새로운 버전이 출시될 때마다 GitHub의 Spring 리포지토리에서 Security의 Release 항목을 통해 변경된 점을 확인할 수 있다

Releases · spring-projects/spring-security (github.com)

주요 버전별 구현

- 스프링 부트 2.X.X ~ 2.6.X (스프링 5.X.X ~ 5.6.X)

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {

				http
	        .authorizeRequests()
            .antMatchers("/").authenticated()
            .anyRequest().permitAll();

    }
}

- 스프링 부트 2.7.X ~ 3,0.X (스프링 5.7.X M2 ~ 6.0.X)

public class SpringSecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http
						.authorizeHttpRequests()
			            .requestMatchers("/admin").hasRole("ADMIN")
			            .anyRequest().authenticated();

        return http.build();
    }
}

- 스프링 부트 3.1.X ~ (스프링 6.1.X ~) 

public class SpringSecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

        http
            .authorizeHttpRequests((auth) -> auth
                  .requestMatchers("/login", "/join").permitAll()
                  .anyRequest().authenticated()
        );

        return http.build();
    }
}

** 3.1.X 버전부터 람다형식 표현 필수...

Config 설정 후 로그인 페이지

스프링 시큐리티 Config 클래스 설정 후 특정 경로에 대한 접근 권한이 없는 경우 자동으로 로그인 페이지로 리다이렉팅 되지 않고 오류 페이지가 발생....

위 문제를 해결하기 위해 Config 클래스를 설정하면 로그인 페이지 설정도 진행해야 한다.

커스텀 로그인 페이지 :  mustache

- login.mustache

- 로그인 : 아이디, 비밀번호 POST 요청 경로

<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    login page
    <hr>
    <form action="/loginProc" method="post" name="loginForm">
        <input id="username" type="text" name="username" placeholder="id"/>
        <input id="password" type="password" name="password" placeholder="password"/>
        <input type="submit" value="login"/>
    </form>
</body>
</html>

LoginController

package com.example.testsecurity.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class LoginController {

    @GetMapping("/login")
    public String loginP() {

        return "login";
    }
}

Security Config 로그인 페이지 설정 및 로그인 경로

- admin 페이지로 가도 바로 로그인 페이지를 띄울 수 있도록 하기 위한 설정..

package com.example.testsecurity.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{

        http
                .authorizeHttpRequests((auth) -> auth
                        .requestMatchers("/", "/login", "/loginProc").permitAll()
                        .requestMatchers("/admin").hasRole("ADMIN")
                        .requestMatchers("/my/**").hasAnyRole("ADMIN", "USER")
                        .anyRequest().authenticated()
                );

		
        // 로그인 페이지에 대한 접근 추가하기
        http
                .formLogin((auth) -> auth.loginPage("/login")
                        .loginProcessingUrl("/loginProc")
                        .permitAll()
                );
		
        // 토큰을 보내지 않으면 로그인이 진행이 안되기 때문에 추후에 푼다고 하심...
        http
                .csrf((auth) -> auth.disable());


        return http.build();
    }
}

근데 mustache 왜 씀??

=> https://velog.io/@qowl880/SpringBoot-Mustache

시큐리티 암호화

스프링 시큐리티는 사용자 인증(로그인) 시 비밀번호에 대해 단방향 해시 암호화를 진행하여 저장되어 있는 비밀번호와 대조된다. 

따라서 회원가입시 비밀번호 항목에 대해서 암호화를 진행해야 한다

스프링 시큐리티는 암호화를 위해 BCrypt Password Encorder를 제공하고 권장한다. 따라서 해당 클래스를 return 하는 메소드를 만들어 @Bean 으로 등록하여 사용하면 된다

단방향 해시 암호화

- 양방향(대칭키, 비대칭키)

- 단방향(헤시)

Security Config 암호화 Bean 추가

@Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() {

    return new BCryptPasswordEncoder();
}

데이터베이스 종류와 ORM

회원 정보를 저장하기 위한 데이터베이스는 MYSQL 엔진의 데이터베이스를 사용한다.

그리고 접근은 Spring Date JPA 를 사용한다

데이터베이스 의존성

dependencies {

    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.mysql:mysql-connector-j'
}

변수 설정

• application.properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://아이피:3306/데이터베이스?useSSL=false&useUnicode=true&serverTimezone=Asia/Seoul&allowPublicKeyRetrieval=true
spring.datasource.username=아이디
spring.datasource.password=비밀번호

회원가입 로직

회원정보를 통해 인증 인가 작업을 진행하기 때문에 사용자로부터 회원 가입을 진행한 뒤 데이터베이스에 회원 정보를 저장해야 한다

회원가입 페이지 : mustache

- join.mustache

<form action="/joinProc" method="post" name="joinForm">
    <input type="text" name="username" placeholder="Username"/>
    <input type="password" name="password" placeholder="Password"/>
		<input type="submit" value="Join"/>
</form>

- JoinDTO

package com.example.testsecurity.dto;

import lombok.Getter;
import lombok.Setter;

@Setter
@Getter
public class JoinDTO {

    private String username;
    private String password;
}

- JoinController

package com.example.testsecurity.controller;

import com.example.testsecurity.dto.JoinDTO;
import com.example.testsecurity.service.JoinService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class JoinController {

    @Autowired
    private JoinService joinService;


    @GetMapping("/join")
    public String joinP() {

        return "join";
    }


    @PostMapping("/joinProc")
    public String joinProcess(JoinDTO joinDTO) {

        System.out.println(joinDTO.getUsername());

        joinService.joinProcess(joinDTO);


        return "redirect:/login";
    }
}

- JoinService

package com.example.testsecurity.service;

import com.example.testsecurity.dto.JoinDTO;
import com.example.testsecurity.entity.UserEntity;
import com.example.testsecurity.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class JoinService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;


    public void joinProcess(JoinDTO joinDTO) {


        //db에 이미 동일한 username을 가진 회원이 존재하는지?


        UserEntity data = new UserEntity();

        data.setUsername(joinDTO.getUsername());
        data.setPassword(bCryptPasswordEncoder.encode(joinDTO.getPassword()));
        data.setRole("ROLE_USER");


        userRepository.save(data);
    }
}

-UserEntity

package com.example.testsecurity.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Getter;
import lombok.Setter;

@Entity
@Setter
@Getter
public class UserEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String username;
    private String password;

    private String role;
}

Table 생성 : Hibernate ddl 설정

- application properties

spring.jpa.hibernate.ddl-auto=none		// none으로 바꾸면 이미 만들어진 테이블을 수정할 수 없지롱
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

- UserRepository

package com.example.testsecurity.repository;

import com.example.testsecurity.entity.UserEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<UserEntity, Integer> {

}

- SecurityConfig 접근 권한

http
          .authorizeHttpRequests((auth) -> auth
                  .requestMatchers("/", "/login", "/loginProc", "/join", "/joinProc").permitAll()
                  .requestMatchers("/admin").hasRole("ADMIN")
                  .requestMatchers("/my/**").hasAnyRole("ADMIN", "USER")
                  .anyRequest().authenticated()
          );