개발일기

[JAVA] 최장 증가 부분 수열 (LIS, Longest Increasing Subsequence)

chb2005 — Sun, 20 Aug 2023 16:25:12 +0900

LIS 란?

Longest Increasing Subsequence
ex) 수열 A = {10, 20, 10, 30, 20, 50}가 주어지고 가장 긴 증가하는 부분 수열을 구하는 문제
- 증가하는 부분 수열을 모두 구해보면 아래와 같음
  - {10}, {20}, {30}, {50}
  - {10, 20}, {10, 30}, {20, 30}, {20, 50}, {30, 50}
  - {10, 20, 30}, {10, 20, 50}, {10, 30, 50}, {20, 30, 50}
  - {10, 20, 30, 50}
- 이 중 가장 길이가 긴 부분 수열은 {10, 20, 30, 50}

해결 방법 1 - O(n^2)

가장 쉬운 해결 방법은 일반적인 dp를 사용하는 방법
dp[i] = dp[i - 1]과 arr[i]를 포함시켜 만들 수 있는 가장 긴 증가하는 부분수열을 비교하여 더 큰 값을 넣어주면 됨
- arr[i]를 포함시켜 만들 수 있는 가장 긴 증가하는 부분수열을 구하는 방법은 arr[0] ~ arr[i - 1] 중 arr[i]보다 값이 작으면서 dp의 해당 index의 값이 가장 큰 값 + 1
ex) arr[] = {10, 20, 10, 30, 20, 50}이 주어졌을 때
- dp[0] = 1 (10을 넣는 방법)
- dp[1] = 2 (10, 20을 넣는 방법), 1 (dp[0]) 중 큰 값 = 2
- dp[2] = 1 (10을 넣는 방법), 2 (dp[1]) 중 큰 값 = 2
- dp[3] = 3 (10, 20, 30을 넣는 방법), 2 (dp[2]) 중 큰 값 = 3
- dp[4] = 2 (10, 20을 넣는 방법), 3 (dp[3]) 중 큰 값 = 3
- dp[5] = 4 (10, 20, 30, 50)을 넣는 방법, 3 (dp[4]) 중 큰 값 = 4
- 정답 = 4

해결 방법 2 - O(nlogn)

해결 방법 1은 이해하기도 쉽고 구현하기도 쉽지만 arr[i]를 포함시켜 만들 수 있는 가장 긴 증가하는 부분수열을 구하기 위해선 0 ~ i-1의 반복문이 필요함
- 시간 복잡도가 n^2
더 빠르게 찾기 위해서 arr[i]를 포함시켜 만들 수 있는 가장 긴 증가하는 부분수열을 구하는 시간을 줄여보자
- dp + 이분 탐색을 활용
arr[] = {10, 20, 9, 30, 20, 50}이 주어졌다고 가정

List 타입의 dp에 0 삽입 (arr의 각각의 값이 1 이상이기 때문)
i = 0일 때, List 타입의 dp에 arr[0] 삽입
i = 1일 때, dp의 마지막 숫자(10)가 arr[i](20)보다 작다면 삽입
i = 2일 때, dp의 마지막 숫자(20)이 arr[i](9)보다 크거나 같음
- 이런 경우에는 이분 탐색을 통해 dp에서 9보다 작은 값 중에서 최대값을 찾음(0)
- 0 뒤에 9 삽입
  - 현재 dp에는 9, 20이 들어있지만 이는 {9, 20}이 가장 긴 증가하는 부분수열이라는 뜻이 아닌 길이가 2가 최대라는 의미
  - 이후에 10이 나온다면 9 뒤에 10을 넣음으로써 {9, 10}으로 만들 수 있기 때문에 위와 같은 작업을 한 것임
i = 3일 때, dp의 마지막 숫자(20)이 arr[i](30)보다 작기 때문에 삽입
i = 4일 때, dp의 마지막 숫자(30)이 arr[i](20)보다 크거나 같기 때문에 9 뒤에 20 삽입
i = 5일 때, dp의 마지막 숫자(30)이 arr[i](50)보다 작기 때문에 삽입
dp의 길이 - 1(첫번째 0 제외) = 4가 정답, 이 때 {9, 20, 30, 50}이 가장 긴 증가하는 부분수열은 아님

구현

백준 12015번 : 가장 긴 증가하는 부분 수열 2

코드

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class p12015 {

    static List<Integer> dp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0 ; i < n ; i ++) {
            arr[i] = sc.nextInt();
        }

        dp = new ArrayList<>();
        dp.add(0);
        dp.add(arr[0]);

        for (int i = 1 ; i < n ; i ++) {
            if (arr[i] > dp.get(dp.size() - 1)) {
                dp.add(arr[i]);
            } else {
                // dp에서 arr[i]보다 작은값 중 가장 큰 값 바로 뒤의 값을 arr[i]로 수정
                // arr[i]보다 작은값 중 가장 큰 값을 찾기 위해 이분 탐색 사용
                binary_search(arr[i]);
            }
        }

        System.out.println(dp.size() - 1);
    }

    private static void binary_search(int x) {
        int left = 0;
        int right = dp.size() - 1;
        int mid = 0;

        while (left <= right) {
            mid = (left + right) / 2;
            if (dp.get(mid) >= x) {
                right = mid - 1;
            } else {
                if (dp.get(mid) < x && dp.get(mid + 1) >= x) {
                    break;
                } else {
                    left = mid + 1;
                }
            }
        }

        dp.set(mid + 1, x);
    }
}

[RDS MySQL] Too many connections 해결 방법

chb2005 — Wed, 3 May 2023 14:11:34 +0900

문제 상황

AWS RDS (MySQL) 사용 중 DB에 접속이 안 됨
Spring Boot 프로젝트 실행 시 ERROR 1040 (08004): Too many connections 에러 발생

원인

다른 프로젝트에서도 해당 DB를 사용하는데, Connection이 중지되지 않고 계속 유지되서 사용할 수 있는 Connection이 없는 상황

해결 방법

RDS DB의 최대 Connections 수 (max_connections)를 늘려주고, 일정 시간이 지나면 Connection을 중지 시키도록 connect_timeout을 설정하여 해결함

AWS RDS console 접속
좌측 탭의 파라미터 그룹 클릭
만약 파라미터 그룹이 하나 있으면 파라미터 그룹 생성 (default는 수정할 수 없기 때문)
아래와 같이 'my-default'라는 그룹을 만들었음

'my-default'를 클릭하면 파라미터를 수정할 수 있음
아래와 같이 connect_timeout(180), max_connections(100) 으로 설정

변경사항 저장
이제 에러가 난 DB에서 수정 클릭

DB 수정페이지에서 'DB 파라미터 그룹'을 방금 생성한 그룹으로 설정 후 계속

'수정 예약'을 즉시 적용 선택 후 DB 인스턴스 수정
마지막으로 DB를 재부팅하면 파라미터가 적용되어 에러 해결

[Linux] Linux(EC2) 용량 부족 문제 해결 방법

chb2005 — Wed, 19 Apr 2023 15:54:48 +0900

문제 상황

프로젝트를 AWS EC2(Linux 환경)에 배포하는 과정에 용량이 부족하다는 메세지가 출력됨
- No space left on device
장치에 남은 공간이 없어 작업을 진행할 수 없는 상황

원인

장치에 남은 공간이 없어서 발생하는 에러
프로젝트의 용량이 크지도 않고, 불필요한 컨테이너와 이미지들도 모두 삭제하고, 로컬에 파일을 저장하는 등의 로직도 없는데도 공간이 부족해짐
원인은 Docker를 사용하면서 컨테이너들을 다루게 되는데, 이 때 사용하지 않는 불필요한 리소스들이 생성되었기 때문이라 함

해결 방법

아래의 명령어를 통해 불필요한 리소스들을 제거할 수 있음

docker system prune -a -f

다른 방법으로는 EC2 인스턴스의 용량을 늘리면 되긴 함

추가 - 남은 용량 확인 방법

아래의 명령어를 통해 현재 남은 용량을 확인할 수 있음

df -h

불필요한 리소스 제거 전 (59% 사용)

불필요한 리소스 제거 후 (46% 사용)

추가 - crontab을 활용하여 주기적으로 불필요한 리소스 제거

[CI/CD] GitLab을 활용한 CI/CD 파이프라인 구축 (+ Linux Crontab) 해당 글 아래쪽에 Linux Crontab에 대해 정리해 놓았으니 참고
매일 오전 5시에 불필요한 리소스들을 제거하는 명령어는 아래와 같음

0 5 * * * docker system prune -a -f

[Spring Boot] 프로젝트 TimeZone 설정

chb2005 — Wed, 19 Apr 2023 15:32:27 +0900

문제 상황

Spring Boot 프로젝트를 로컬에서 실행했을 때는 DB에 데이터를 삽입할 때, createdAt이 제대로 삽입됨
하지만 EC2로 배포 후 데이터를 삽입하면 한국 시간으로 들어가지 않고, 시간이 UTC로 들어가는 문제가 발생함 (한국 시간 -9)

원인

EC2 인스턴스 자체의 TimeZone을 바꿔봐도 해당 문제는 여전히 발생
프로젝트 자체의 TimeZone이 문제라고 생각함

해결 방법

아래의 코드를 통해 프로젝트의 TimeZone을 서울로 맞춰주면 됨
이 코드는 프로젝트의 main 클래스나 @Component로 등록한 클래스 내부에 적어줘야 실행됨
@PostConstruct는 프로젝트가 처음 실행될 때, 한 번만 실행 시켜주는 어노테이션

@PostConstruct
public void setTimeZone(){
    TimeZone.setDefault(TimeZone.getTimeZone("Asia/Seoul"));
}

[Spring Boot] AWS S3를 이용한 파일 업로드

chb2005 — Tue, 18 Apr 2023 17:59:45 +0900

AWS S3 란?

AWS Simple Storage Service의 줄임말로 파일 서버의 역할을 하는 서비스
프로젝트 개발 중 파일을 저장하고 불러오는 작업이 필요한 경우에 프로젝트 내부 폴더에 저장할 수 있지만, AWS S3를 사용하여 파일을 관리할 수도 있음

AWS S3의 장점

무제한 용량 (하나의 파일에 대한 용량 제한은 있지만, 전체 용량은 무제한)
파일 저장에 최적화 (개발자가 따로 용량을 추가하거나 성능을 높이는 작업을 하지 않아도 됨)
99.999%라는 높은 내구도 (파일이 유실될 가능성이 낮음)
이 외에도 저렴한 비용, 높은 객체 가용성, 뛰어난 보안성 등의 장점이 있음

AWS S3 생성

객체(Object) : 파일과 파일정보로 구성된 저장단위로 파일이라 생각하면 됨
버킷(Bucket) : 저장된 객체에 대한 컨테이너
버킷은 최대 100개 생성 가능하며, 버킷에 저장할 수 있는 객체수는 제한이 없음

Bucket 생성

AWS Console 접속 후 S3 서비스 선택
버킷 만들기 클릭
원하는 버킷 이름 입력
AWS 리전 선택 (아시아 태평양(서울) ap-northeast-2 )
객체 소유권 선택 (ACL 비활성화)
'모든 퍼블릭 액세스 차단' 해제
나머지는 Default

사용자 생성

AWS Console 접속 후 IAM 서비스 선택
액세스 관리 -> 사용자 -> 사용자 추가
원하는 이름 입력 후 다음
직접 정책 연결 -> AmazonS3FullAccess 선택 후 다음
사용자 생성

액세스 키 생성

방금 생성한 사용자 선택 후 보안 자격 증명 탭 클릭
액세스 키 만들기 클릭
기타 선택 후 다음
원하는 설명 태그 입력 후 액세스 키 만들기
액세스 키를 만들면 아래와 같이 액세스 키와 비밀 액세스 키를 확인할 수 있는데, 이 값들을 저장후 완료

버킷 정책 변경

AWS Console에서 생성한 버킷으로 이동
권한 -> 버킷 정책 -> 편집
정책이 비어있으면 '+ 새 문 추가' 클릭
정책 내용을 아래와 같이 변경

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Statement1",
            "Principal": "*",
            "Effect": "Allow",
            "Action": "s3:*",
            "Resource": "arn:aws:s3:::<버킷 이름>/*"
        }
    ]
}

Spring 프로젝트와 연동

라이브러리 추가 (build.gradle)

implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE'

application.yml에 아래 내용 추가

cloud:
  aws:
    s3:
      bucket: <S3 버킷 이름>
    credentials:
      access-key: <저장해놓은 액세스 키>
      secret-key: <저장해놓은 비밀 액세스 키>
    region:
      static: ap-northeast-2
      auto: false
    stack:
      auto: false

S3Config.java 생성

@Configuration
public class S3Config {

    @Value("${cloud.aws.credentials.access-key}")
    private String accessKey;

    @Value("${cloud.aws.credentials.secret-key}")
    private String secretKey;

    @Value("${cloud.aws.region.static}")
    private String region;

    @Bean
    public AmazonS3Client amazonS3Client() {
        BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);

        return (AmazonS3Client) AmazonS3ClientBuilder
                .standard()
                .withRegion(region)
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .build();
    }
}

파일 업로드 구현

@Service
@RequiredArgsConstructor
public class S3UploadService {

    private final AmazonS3 amazonS3;

    @Value("${cloud.aws.s3.bucket}")
    private String bucket;

    public String saveFile(MultipartFile multipartFile) throws IOException {
        String originalFilename = multipartFile.getOriginalFilename();

        ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentLength(multipartFile.getSize());
        metadata.setContentType(multipartFile.getContentType());

        amazonS3.putObject(bucket, originalFilename, multipartFile.getInputStream(), metadata);
        return amazonS3.getUrl(bucket, originalFilename).toString();
    }
}

putObject() 메소드가 파일을 저장해주는 메소드
getURl()을 통해 파일이 저장된 URL을 return 해주고, 이 URL로 이동 시 해당 파일이 오픈됨 (버킷 정책 변경을 하지 않았으면 파일은 업로드 되지만 해당 URL로 이동 시 accessDenied 됨)
만약 MultipartFile에 대해 잘 모르거나 웹 페이지에서 form으로 파일을 입력받고 싶다면 [Spring Boot] 파일 업로드 참고

파일 다운로드 구현

public ResponseEntity<UrlResource> downloadImage(String originalFilename) {
    UrlResource urlResource = new UrlResource(amazonS3.getUrl(bucket, originalFilename));

    String contentDisposition = "attachment; filename=\"" +  originalFilename + "\"";

    // header에 CONTENT_DISPOSITION 설정을 통해 클릭 시 다운로드 진행
    return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, contentDisposition)
            .body(urlResource);

}

로컬 파일 다운로드 할 때에는 UrlResource() 메소드에 "file:" + 로컬 파일 경로를 넣어주면 로컬 파일이 다운로드 되었음
S3에 올라간 파일은 위와 같이 amazonS3.getUrl(버킷이름, 파일이름)을 통해 파일 다운로드를 할 수 있음

HTML 파일에서 이미지 미리보기 구현

String url = amazonS3.getUrl(bucket, filename).toString();

위에서 구한 amazonS3 URL을 Model에 담아 HTML 파일로 전송
아래와 같이 Thymeleaf를 이용해 URL을 받고 src에 넣어주면 화면에서 이미지 미리보기 가능

<img th:src="${s3ImageUrl}"/>

파일 삭제 구현

public void deleteImage(String originalFilename)  {
    amazonS3.deleteObject(bucket, originalFilename);
}

[Spring Boot] 게시판 만들기 6 - 화면 제작

chb2005 — Mon, 17 Apr 2023 16:20:42 +0900

HTML, Thymeleaf, BootStrap, JavaScript, JQuery를 사용하여 화면 제작
디자인이나 화면에 대해 자세히는 정리하지는 않고 핵심적인 부분만 설명
화면 관련 코드에 전체 코드가 있으니 참고
Thyemleaf와 관련된 것은 [Spring Boot] Thymeleaf 기능 정리, [Spring Boot] Thymeleaf - form 관련 기능 정리 참고

printMessage.html

이 페이지는 내용을 출력하기 위한 페이지가 아닌 javascript를 통해 메세지를 출력해주고, 바로 다음 페이지로 이동시켜주는 페이지

<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>게시판</title>
</head>
<body>
  <script th:inline="javascript">
    window.onload = function () {
      if([[${message}]] != null) {
        alert([[${message}]])
      }
      window.location.href = [[${nextUrl}]]
    }
  </script>
</body>
</html>

header.html

화면 상단의 nav-bar와 Bootstrap, css 등을 import 해주는 페이지
모든 페이지에 같은 nav-bar가 들어가기 때문에 한번 만들어 놓고 thymeleaf의 fragment를 통해 다른 페이지에서는 <div th:replace="fragments/header.html :: header ('admin')"/> 이런 식으로 불러서 사용하기만 하면 됨
thymeleaf-extras-springsecurity5 라이브러리를 설치하고, html 태그에 xmlns:sec="http://www.thymeleaf.org/extras/spring-security"를 추가해주면 sec:authorize="isAuthenticated()", sec:authorize="hasAuthority('ADMIN')" 와 같이 인증, 인가를 쉽게 할 수 있음

<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org" xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<head th:fragment="head">
    <meta charset="utf-8">
    <title>게시판</title>
    <!-- Bootstrap 5.2.3 Version -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">

    <!-- My CSS -->
    <link rel="stylesheet" href="/css/custom.css">

    <!-- JQuery -->
    <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>

</head>

<body>

<div th:fragment="header (pageName)">
    <!-- Bootstrap 5.2.3 Version -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>

    <nav class="navbar navbar-expand-lg" style="background-color: limegreen; margin-bottom: 60px;">
        <div class="container-fluid">
            <a class="navbar-brand" href="/">Basic Board</a>
            <div class="collapse navbar-collapse" id="navbarNavDropdown">
                <!--<ul class="navbar-nav">-->
                <ul class="navbar-nav">
                    <li class="nav-item">
                        <a th:if="${pageName == 'home'}" class="nav-link active" aria-current="page" href="/">Home</a>
                        <a th:unless="${pageName == 'home'}" class="nav-link" aria-current="page" href="/">Home</a>
                    </li>
                    <li class="nav-item">
                        <a th:if="${pageName == 'greeting'}" class="nav-link active" aria-current="page" href="/boards/greeting">가입인사</a>
                        <a th:unless="${pageName == 'greeting'}" class="nav-link" aria-current="page" href="/boards/greeting">가입인사</a>
                    </li>
                    <li class="nav-item">
                        <a th:if="${pageName == 'free'}" class="nav-link active" aria-current="page" href="/boards/free">자유게시판</a>
                        <a th:unless="${pageName == 'free'}" class="nav-link" aria-current="page" href="/boards/free">자유게시판</a>
                    </li>
                    <li class="nav-item">
                        <a th:if="${pageName == 'gold'}" class="nav-link active" aria-current="page" href="/boards/gold">골드게시판</a>
                        <a th:unless="${pageName == 'gold'}" class="nav-link" aria-current="page" href="/boards/gold">골드게시판</a>
                    </li>
                </ul>
            </div>
            <div class="justify-content-between" id="navbarNav" style="padding: 5px 30px">

                <!-- 로그인 안 했을때 -->
                <ul class="navbar-nav" sec:authorize="isAnonymous()">
                    <li class="nav-item">
                        <button class="btn nav-btn" onclick="location.href = '/users/login'">로그인</button>
                    </li>
                    <li class="nav-item">
                        <button class="btn nav-btn" onclick="location.href = '/users/join'">회원가입</button>
                    </li>
                </ul>

                <!-- 로그인 했을때 -->
                <ul class="navbar-nav" sec:authorize="isAuthenticated()">
                    <li class="nav-item" sec:authorize="hasAuthority('ADMIN')">
                        <button class="btn nav-btn" onclick="location.href = '/users/admin'" style="width: fit-content">관리자 페이지</button>
                    </li>
                    <li class="nav-item">
                        <button class="btn nav-btn" onclick="location.href = '/users/myPage/board'">마이페이지</button>
                    </li>
                    <li class="nav-item">
                        <button class="btn nav-btn" onclick="location.href = '/users/logout'">로그아웃</button>
                    </li>
                </ul>

            </div>
        </div>
    </nav>
</div>

</body>

확인 메세지 출력

function clickDelete() {
    if (confirm("해당 글을 삭제 하시겠습니까?") == true) {
        location.href = "/boards/" + [[${category}]] + "/" + [[${boardDto.id}]] + "/delete";
    }
}

boards/detail.html에서 위와 같은 코드가 있음
이 코드는 버튼을 눌렀을 때, 바로 GET 요청을 보내지 않고 확인 메세지를 출력해 줌
확인 메세지에서 확인 버튼을 눌러야 if 문 안의 내용이 실행됨

페이지 기능 구현

window.onload = function () {
    let nowPage = [[${boards.getNumber()}]] + 1;    // 현재 페이지
    let totalPage = [[${boards.getTotalPages()}]];  // 전체 페이지 수

    let firstPage;  // 화면에 출력될 첫 페이지
    for (let i = nowPage ; i >= 1 ; i --) {
        if(i % 5 == 1) {
            firstPage = i;
            break;
        }
    }

    let lastPage;   // 화면에 출력될 마지막 페이지
    let nextButton; // 다음 버튼 출력 여부
    if (firstPage + 4 >= totalPage) {
        lastPage = totalPage;
        nextButton = false;
    } else {
        lastPage = firstPage + 4;
        nextButton = true;
    }

    // HTML 생성
    let pageHtml = "";
    pageHtml += "<li><a class='page-link' href='" + makeUrl(1) +  "'>&laquo;</a></li>";
    if (firstPage != 1) {
        pageHtml += "<li><a class='page-link' href='" + makeUrl(firstPage - 1) +  "'>&lsaquo;</a></li>";
    }

    for (let i = firstPage; i <= lastPage; i++) {
        if (i == nowPage) {
            pageHtml += "<li class='page-item active'><a class= 'page-link'>" + i + "</a></li>";
        } else {
            pageHtml += "<li class='page-item'><a class= 'page-link' href='" + makeUrl(i) + "'>" + i + "</a></li>";
        }
    }

    if (nextButton) {
        pageHtml += "<li><a class='page-link' href='" + makeUrl(lastPage + 1) +  "'>&rsaquo;</a></li>";
    }
    pageHtml += "<li><a class='page-link' href='" + makeUrl(totalPage) +  "'>&raquo;</a></li>";

    $("#paging-ul").html(pageHtml);
}

function makeUrl(page) {
    let category = [[${category}]];
    let url = "/boards/" + category + "?page=" + page;

    // 검색 했으면 다음 URL에도 추가
    let sortType = [[${boardSearchRequest.sortType}]];
    let searchType = [[${boardSearchRequest.searchType}]];
    let keyword = [[${boardSearchRequest.keyword}]];

    if (sortType != null) {
        url += "&sortType=" + sortType;
    }
    if (searchType != null) {
        url += "&searchType=" + searchType + "&keyword=" + keyword;
    }

    return url;
}

boards/list.html에서 위와 같은 코드가 있음
이 코드는 해당 html 파일이 open 될 때 페이지 버튼을 만드는 코드
이 사이트에서는 1 ~ 5, ^ ~ 10과 같이 5개의 페이지 단위로 버튼을 생성함
Model로 넘어온 값들을 Thymeleaf 문법을 사용해 받고, 현재 페이지와 전체 페이지를 통해 첫번째 페이지, 마지막 페이지를 계산하고, 버튼을 생성함
또한, 정렬, 검색을 했다면 sortType, searchType, keyword가 넘어오게 되는데, 이 값들을 url에 추가해줌으로써, 검색, 정렬 후 페이지 이동을 했을 때, 검색, 정렬 결과가 유지될 수 있게 해줌

파일 입력

<form class="offset-3 col-6 form-group" th:object="${boardCreateRequest}" th:method="post"
        th:action="|@{/boards/{category} (category = ${category})}|" enctype="multipart/form-data">
    <div>
        <label th:for="title">제목 : </label>
        <input type="text" th:field="*{title}" style="width: 50%">
    </div>
    <br/>

    <div>
        <label th:for="body">내용 : </label>
        <textarea rows="10" style="width: 100%;" th:field="*{body}"/>
    </div>
    <br/>
    <div>
        <label th:for="uploadImage">이미지 첨부 : </label>
        <input type="file" th:field="*{uploadImage}" style="width: 50%">
    </div>
    <br/>
    <div align="center">
        <button class="btn post-btn" type="submit">등록</button>
    </div>
</form>

위 코드는 제목, 내용, 이미지를 입력받는 코드
form을 통해 text를 입력 받는것 외에도 파일을 입력 받아야 하기 때문에 form 태그에 enctype="multipart/form-data"를 추가해주고, input type file로 파일을 입력받을 수 있음
이전에 작성한 글 ([Spring Boot] 게시판 만들기 4 - 게시판 기능의 BoardController와 [Spring Boot] 게시판 만들기 5 - 댓글, 좋아요, 파일 업로드 기능의 UploadService에서 파일 입력을 받으니 참고)

[Spring Boot] 게시판 만들기 5 - 댓글, 좋아요, 파일 업로드 관련 기능

chb2005 — Mon, 17 Apr 2023 16:10:07 +0900

댓글 관련 코드

CommentRepository

@Repository
public interface CommentRepository extends JpaRepository<Comment, Long> {
    List<Comment> findAllByBoardId(Long boardId);
    List<Comment> findAllByUserLoginId(String loginId);
}

CommentService

댓글에 관련된 CRUD

@Service
@RequiredArgsConstructor
public class CommentService {

    private final CommentRepository commentRepository;
    private final BoardRepository boardRepository;
    private final UserRepository userRepository;

    public void writeComment(Long boardId, CommentCreateRequest req, String loginId) {
        Board board = boardRepository.findById(boardId).get();
        User user = userRepository.findByLoginId(loginId).get();
        board.commentChange(board.getCommentCnt() + 1);
        commentRepository.save(req.toEntity(board, user));
    }

    public List<Comment> findAll(Long boardId) {
        return commentRepository.findAllByBoardId(boardId);
    }

    @Transactional
    public Long editComment(Long commentId, String newBody, String loginId) {
        Optional<Comment> optComment = commentRepository.findById(commentId);
        Optional<User> optUser = userRepository.findByLoginId(loginId);
        if (optComment.isEmpty() || optUser.isEmpty() || !optComment.get().getUser().equals(optUser.get())) {
            return null;
        }

        Comment comment = optComment.get();
        comment.update(newBody);

        return comment.getBoard().getId();
    }

    public Long deleteComment(Long commentId, String loginId) {
        Optional<Comment> optComment = commentRepository.findById(commentId);
        Optional<User> optUser = userRepository.findByLoginId(loginId);
        if (optComment.isEmpty() || optUser.isEmpty() ||
                (!optComment.get().getUser().equals(optUser.get()) && !optUser.get().getUserRole().equals(UserRole.ADMIN))) {
            return null;
        }

        Board board = optComment.get().getBoard();
        board.commentChange(board.getCommentCnt() + 1);

        commentRepository.delete(optComment.get());
        return board.getId();
    }
}

CommentController

댓글 추가, 수정, 삭제 시 완료 메세지 출력 후 해당 댓글이 포함된 게시글 페이지로 이동

@Controller
@RequestMapping("/comments")
@RequiredArgsConstructor
public class CommentController {

    private final CommentService commentService;
    private final BoardService boardService;

    @PostMapping("/{boardId}")
    public String addComments(@PathVariable Long boardId, @ModelAttribute CommentCreateRequest req,
                                     Authentication auth, Model model) {
        commentService.writeComment(boardId, req, auth.getName());

        model.addAttribute("message", "댓글이 추가되었습니다.");
        model.addAttribute("nextUrl", "/boards/" + boardService.getCategory(boardId) + "/" + boardId);
        return "printMessage";
    }

    @PostMapping("/{commentId}/edit")
    public String editComment(@PathVariable Long commentId, @ModelAttribute CommentCreateRequest req,
                              Authentication auth, Model model) {
        Long boardId = commentService.editComment(commentId, req.getBody(), auth.getName());
        model.addAttribute("message", boardId == null? "잘못된 요청입니다." : "댓글이 수정 되었습니다.");
        model.addAttribute("nextUrl", "/boards/" + boardService.getCategory(boardId) + "/" + boardId);
        return "printMessage";
    }

    @GetMapping("/{commentId}/delete")
    public String deleteComment(@PathVariable Long commentId, Authentication auth, Model model) {
        Long boardId = commentService.deleteComment(commentId, auth.getName());
        model.addAttribute("message", boardId == null? "작성자만 삭제 가능합니다." : "댓글이 삭제 되었습니다.");
        model.addAttribute("nextUrl", "/boards/" + boardService.getCategory(boardId) + "/" + boardId);
        return "printMessage";
    }
}

CommentCreateRequest

댓글을 입력받아 DB에 저장할 때 사용하는 DTO

@Data
public class CommentCreateRequest {

    private String body;

    public Comment toEntity(Board board, User user) {
        return Comment.builder()
                .user(user)
                .board(board)
                .body(body)
                .build();
    }
}

좋아요 관련 코드

LikeRepository

@Repository
public interface LikeRepository extends JpaRepository<Like, Long> {
    void deleteByUserLoginIdAndBoardId(String loginId, Long boardId);
    Boolean existsByUserLoginIdAndBoardId(String loginId, Long boardId);
    List<Like> findAllByUserLoginId(String loginId);
}

LikeService

좋아요 추가, 삭제 및 로그인 한 유저가 특정 게시글에 좋아요를 눌렀는지 여부 확인

@Service
@RequiredArgsConstructor
public class LikeService {

    private final LikeRepository likeRepository;
    private final UserRepository userRepository;
    private final BoardRepository boardRepository;

    @Transactional
    public void addLike(String loginId, Long boardId) {
        Board board = boardRepository.findById(boardId).get();
        User loginUser = userRepository.findByLoginId(loginId).get();
        User boardUser = board.getUser();

        // 자신이 누른 좋아요가 아니라면
        if (!boardUser.equals(loginUser)) {
            boardUser.likeChange(boardUser.getReceivedLikeCnt() + 1);
        }
        board.likeChange(board.getLikeCnt() + 1);

        likeRepository.save(Like.builder()
                        .user(loginUser)
                        .board(board)
                        .build());
    }

    @Transactional
    public void deleteLike(String loginId, Long boardId) {
        Board board = boardRepository.findById(boardId).get();
        User loginUser = userRepository.findByLoginId(loginId).get();
        User boardUser = board.getUser();

        // 자신이 누른 좋아요가 아니라면
        if (!boardUser.equals(loginUser)) {
            boardUser.likeChange(boardUser.getReceivedLikeCnt() - 1);
        }
        board.likeChange(board.getLikeCnt() - 1);

        likeRepository.deleteByUserLoginIdAndBoardId(loginId, boardId);
    }

    public Boolean checkLike(String loginId, Long boardId) {
        return likeRepository.existsByUserLoginIdAndBoardId(loginId, boardId);
    }
}

LikeController

댓글과는 달리 메세지를 출력하지 않기 때문에 redirect를 통해 바로 이동

@Controller
@RequestMapping("/likes")
@RequiredArgsConstructor
public class LikeController {

    private final LikeService likeService;
    private final BoardService boardService;

    @GetMapping("/add/{boardId}")
    public String addLike(@PathVariable Long boardId, Authentication auth) {
        likeService.addLike(auth.getName(), boardId);
        return "redirect:/boards/" + boardService.getCategory(boardId) + "/" + boardId;
    }

    @GetMapping("/delete/{boardId}")
    public String deleteLike(@PathVariable Long boardId, Authentication auth) {
        likeService.deleteLike(auth.getName(), boardId);
        return "redirect:/boards/" + boardService.getCategory(boardId) + "/" + boardId;
    }
}

파일 업로드 관련 코드

UploadImageRepository

@Repository
public interface UploadImageRepository extends JpaRepository<UploadImage, Long> {
}

UploadImageService

saveImage() 메소드에서 입력된 파일의 이름을 "UUID + 원본 파일의 확장자"로 바꿔서 저장
downloadImage() 메소드에서는 다시 원본 파일명으로 수정 후 파일 return
이 프로젝트에서 파일 업로드 기능은 로컬 프로젝트에 "/src/main/resources/static/upload-images" 폴더를 추가하고 해당 폴더에 이미지를 업로드하는 방식
- 따라서 해당 경로에 폴더가 없으면 에러가 발생할 수 있기 때문에 직접 폴더를 추가해줘야 함
- 만약 이 프로젝트를 EC2 서버로 배포하고 싶다면 EC2 인스턴스 프로젝트 내부에서 파일을 관리해도 되지만, AWS S3를 사용하는 것도 좋은 방법이라 생각함
- [Spring Boot] AWS S3를 이용한 파일 업로드 참고

@Service
@RequiredArgsConstructor
public class UploadImageService {

    private final UploadImageRepository uploadImageRepository;
    private final BoardRepository boardRepository;
    private final String rootPath = System.getProperty("user.dir");
    private final String fileDir = rootPath + "/src/main/resources/static/upload-images/";

    public String getFullPath(String filename) {
        return fileDir + filename;
    }

    public UploadImage saveImage(MultipartFile multipartFile, Board board) throws IOException {
        if (multipartFile.isEmpty()) {
            return null;
        }

        String originalFilename = multipartFile.getOriginalFilename();
        // 원본 파일명 -> 서버에 저장된 파일명 (중복 X)
        // 파일명이 중복되지 않도록 UUID로 설정 + 확장자 유지
        String savedFilename = UUID.randomUUID() + "." + extractExt(originalFilename);

        // 파일 저장
        multipartFile.transferTo(new File(getFullPath(savedFilename)));

        return uploadImageRepository.save(UploadImage.builder()
                .originalFilename(originalFilename)
                .savedFilename(savedFilename)
                .board(board)
                .build());
    }

    @Transactional
    public void deleteImage(UploadImage uploadImage) throws IOException {
        uploadImageRepository.delete(uploadImage);
        Files.deleteIfExists(Paths.get(getFullPath(uploadImage.getSavedFilename())));
    }

    // 확장자 추출
    private String extractExt(String originalFilename) {
        int pos = originalFilename.lastIndexOf(".");
        return originalFilename.substring(pos + 1);
    }

    public ResponseEntity<UrlResource> downloadImage(Long boardId) throws MalformedURLException {
        // boardId에 해당하는 게시글이 없으면 null return
        Board board = boardRepository.findById(boardId).get();
        if (board == null || board.getUploadImage() == null) {
            return null;
        }

        UrlResource urlResource = new UrlResource("file:" + getFullPath(board.getUploadImage().getSavedFilename()));

        // 업로드 한 파일명이 한글인 경우 아래 작업을 안해주면 한글이 깨질 수 있음
        String encodedUploadFileName = UriUtils.encode(board.getUploadImage().getOriginalFilename(), StandardCharsets.UTF_8);
        String contentDisposition = "attachment; filename=\"" + encodedUploadFileName + "\"";

        // header에 CONTENT_DISPOSITION 설정을 통해 클릭 시 다운로드 진행
        return ResponseEntity.ok()
                .header(HttpHeaders.CONTENT_DISPOSITION, contentDisposition)
                .body(urlResource);

    }
}

[Spring Boot] 게시판 만들기 4 - 게시판 기능

chb2005 — Mon, 17 Apr 2023 16:06:21 +0900

게시판 기능

글 작성, 조회, 수정, 삭제, 리스트 조회, 댓글, 좋아요 기능
자세한 기능 설계는 [Spring Boot] 게시판 만들기 1 - 설계 & 결과 참고

BoardRepository

findAllByCategoryAndUserUserRoleNot() : 해당 카테고리에 있는 게시글을 페이지에 맞게 조회, 이 때 ADMIN이 작성한 글(공지)는 포함 X
findAllByCategoryAndUserUserRole() : 해당 카테고리에 있는 공지 글 조회
findAllByCategoryAndTitleContainsAndUserUserRoleNot(), findAllByCategoryAndUserNicknameContainsAndUserUserRoleNot() : 검색 기능에 사용
findAllByUserLoginId() : 유저의 마이 페이지에서 내가 작성한 글 조회 시 사용
countAllByUserUserRole() : 전체 공지글이 몇개 있는지 조회 시 사용
countAllByCategoryAndUserUserRoleNot() : 해당 카테고리에 공지글을 제외한 글이 몇개 있는지 조회 시 사용

@Repository
public interface BoardRepository extends JpaRepository<Board, Long> {

    Page<Board> findAllByCategoryAndUserUserRoleNot(BoardCategory category, UserRole userRole, PageRequest pageRequest);
    Page<Board> findAllByCategoryAndTitleContainsAndUserUserRoleNot(BoardCategory category, String title, UserRole userRole, PageRequest pageRequest);
    Page<Board> findAllByCategoryAndUserNicknameContainsAndUserUserRoleNot(BoardCategory category, String nickname, UserRole userRole, PageRequest pageRequest);
    List<Board> findAllByUserLoginId(String loginId);
    List<Board> findAllByCategoryAndUserUserRole(BoardCategory category, UserRole userRole);
    Long countAllByUserUserRole(UserRole userRole);
    Long countAllByCategoryAndUserUserRoleNot(BoardCategory category, UserRole userRole);
}

BoardService

getBoardList() : 해당 카테고리에 있는 글 list를 return
- 이 때, 검색을 했다면 제목, 유저 닉네임에 키워드가 포함되는 글을 return
writeBoard() : 글 작성
- Board 저장 -> 이미지가 있다면 이미지 저장 후 저장된 Board에 해당 이미지 정보 추가 삽입
- 만약 가입 인사 게시판에 글이 저장된 경우라면 로그인 한 유저의 등급을 SILVER로 조정
findMyBoard() : 마이 페이지에서 내가 작성한 글, 내가 좋아요 누른 글, 내가 댓글을 추가한 글을 category로 분류해 List를 return 해주는 메소드
- 내가 좋아요 누른 글은 로그인 한 유저의 loginId를 가지는 Like를 모두 불러온 후 Like에 저장된 Board들을 List로 변환 후 return
- 내가 댓글을 추가한 글도 좋아요와 비슷하긴 하지만 하나의 글에 여러개의 댓글을 단 경우, 한번만 return 되게 하기 위해 HashSet을 사용하여 중복을 제거해서 return

@Service
@RequiredArgsConstructor
public class BoardService {

    private final BoardRepository boardRepository;
    private final UserRepository userRepository;
    private final LikeRepository likeRepository;
    private final CommentRepository commentRepository;
    private final UploadImageService uploadImageService;

    public Page<Board> getBoardList(BoardCategory category, PageRequest pageRequest, String searchType, String keyword) {
        if (searchType != null && keyword != null) {
            if (searchType.equals("title")) {
                return boardRepository.findAllByCategoryAndTitleContainsAndUserUserRoleNot(category, keyword, UserRole.ADMIN, pageRequest);
            } else {
                return boardRepository.findAllByCategoryAndUserNicknameContainsAndUserUserRoleNot(category, keyword, UserRole.ADMIN, pageRequest);
            }
        }
        return boardRepository.findAllByCategoryAndUserUserRoleNot(category, UserRole.ADMIN, pageRequest);
    }

    public List<Board> getNotice(BoardCategory category) {
        return boardRepository.findAllByCategoryAndUserUserRole(category, UserRole.ADMIN);
    }

    public BoardDto getBoard(Long boardId, String category) {
        Optional<Board> optBoard = boardRepository.findById(boardId);

        // id에 해당하는 게시글이 없거나 카테고리가 일치하지 않으면 null return
        if (optBoard.isEmpty() || !optBoard.get().getCategory().toString().equalsIgnoreCase(category)) {
            return null;
        }

        return BoardDto.of(optBoard.get());
    }

    @Transactional
    public Long writeBoard(BoardCreateRequest req, BoardCategory category, String loginId, Authentication auth) throws IOException {
        User loginUser = userRepository.findByLoginId(loginId).get();

        Board savedBoard = boardRepository.save(req.toEntity(category, loginUser));

        UploadImage uploadImage = uploadImageService.saveImage(req.getUploadImage(), savedBoard);
        if (uploadImage != null) {
            savedBoard.setUploadImage(uploadImage);
        }

        if (category.equals(BoardCategory.GREETING)) {
            loginUser.rankUp(UserRole.SILVER, auth);
        }
        return savedBoard.getId();
    }

    @Transactional
    public Long editBoard(Long boardId, String category, BoardDto dto) throws IOException {
        Optional<Board> optBoard = boardRepository.findById(boardId);

        // id에 해당하는 게시글이 없거나 카테고리가 일치하지 않으면 null return
        if (optBoard.isEmpty() || !optBoard.get().getCategory().toString().equalsIgnoreCase(category)) {
            return null;
        }

        Board board = optBoard.get();
        // 게시글에 이미지가 있었으면 삭제
        if (board.getUploadImage() != null) {
            uploadImageService.deleteImage(board.getUploadImage());
            board.setUploadImage(null);
        }

        UploadImage uploadImage = uploadImageService.saveImage(dto.getNewImage(), board);
        if (uploadImage != null) {
            board.setUploadImage(uploadImage);
        }
        board.update(dto);

        return board.getId();
    }

    public Long deleteBoard(Long boardId, String category) throws IOException {
        Optional<Board> optBoard = boardRepository.findById(boardId);

        // id에 해당하는 게시글이 없거나 카테고리가 일치하지 않으면 null return
        if (optBoard.isEmpty() || !optBoard.get().getCategory().toString().equalsIgnoreCase(category)) {
            return null;
        }

        User boardUser = optBoard.get().getUser();
        boardUser.likeChange(boardUser.getReceivedLikeCnt() - optBoard.get().getLikeCnt());
        if (optBoard.get().getUser() != null) {
            uploadImageService.deleteImage(optBoard.get().getUploadImage());
        }
        boardRepository.deleteById(boardId);
        return boardId;
    }

    public String getCategory(Long boardId) {
        Board board = boardRepository.findById(boardId).get();
        return board.getCategory().toString().toLowerCase();
    }

    public List<Board> findMyBoard(String category, String loginId) {
        if (category.equals("board")) {
            return boardRepository.findAllByUserLoginId(loginId);
        } else if (category.equals("like")) {
            List<Like> likes = likeRepository.findAllByUserLoginId(loginId);
            List<Board> boards = new ArrayList<>();
            for (Like like : likes) {
                boards.add(like.getBoard());
            }
            return boards;
        } else if (category.equals("comment")) {
            List<Comment> comments = commentRepository.findAllByUserLoginId(loginId);
            List<Board> boards = new ArrayList<>();
            HashSet<Long> commentIds = new HashSet<>();

            for (Comment comment : comments) {
                if (!commentIds.contains(comment.getBoard().getId())) {
                    boards.add(comment.getBoard());
                    commentIds.add(comment.getBoard().getId());
                }
            }
            return boards;
        }
        return null;
    }

    public BoardCntDto getBoardCnt(){
        return BoardCntDto.builder()
                .totalBoardCnt(boardRepository.count())
                .totalNoticeCnt(boardRepository.countAllByUserUserRole(UserRole.ADMIN))
                .totalGreetingCnt(boardRepository.countAllByCategoryAndUserUserRoleNot(BoardCategory.GREETING, UserRole.ADMIN))
                .totalFreeCnt(boardRepository.countAllByCategoryAndUserUserRoleNot(BoardCategory.FREE, UserRole.ADMIN))
                .totalGoldCnt(boardRepository.countAllByCategoryAndUserUserRoleNot(BoardCategory.GOLD, UserRole.ADMIN))
                .build();
    }
}

BoardController

/boards/{category} : 카테고리에 해당하는 글 리스트를 return 하는 URL
- sortType으로 정렬 방식을 입력받아 PageRequest 설정을 통해 정렬 구현
- searchType, keyword로 글 제목, 작성자 닉네임에 keyword가 포함되는 글을 return 함으로써 검색 기능 구현
/boards/{category}/{boardId} : 게시글 상세 조회 페이지
- 만약 로그인 한 유저라면 loginUserLoginId를 전송함으로써, 화면에서 본인이 작성한 글인지 확인 할 수 있게함
- 로그인 한 유저가 이 글에 좋아요를 눌렀는지 여부를 likeCheck에 담아 전송함으로써, 화면에서 하트를 누르면 좋아요를 추가 시킬지, 제거 시킬지 알 수 있게함
- 또한, 글 상세 페이지에서는 해당 글에 추가된 댓글 리스트도 같이 전송 시킴
/boards/images/{filename} : Resource 타입으로 파일을 전송함으로써, 해당 게시글에 추가된 이미지를 화면에서 출력시킴
/boards/images/download/{filename} : ResponseEntity<UrlResource> 타입으로 파일을 전송함으로써, 해당 URL에 접속 시 저장된 이미지를 다운로드 하게 함

@Controller
@RequestMapping("/boards")
@RequiredArgsConstructor
public class BoardController {

    private final BoardService boardService;
    private final LikeService likeService;
    private final CommentService commentService;
    private final UploadImageService uploadImageService;

    @GetMapping("/{category}")
    public String boardListPage(@PathVariable String category, Model model,
                                @RequestParam(required = false, defaultValue = "1") int page,
                                @RequestParam(required = false) String sortType,
                                @RequestParam(required = false) String searchType,
                                @RequestParam(required = false) String keyword) {
        BoardCategory boardCategory = BoardCategory.of(category);
        if (boardCategory == null) {
            model.addAttribute("message", "카테고리가 존재하지 않습니다.");
            model.addAttribute("nextUrl", "/");
            return "printMessage";
        }

        model.addAttribute("notices", boardService.getNotice(boardCategory));

        PageRequest pageRequest = PageRequest.of(page - 1, 10, Sort.by("id").descending());
        if (sortType != null) {
            if (sortType.equals("date")) {
                pageRequest = PageRequest.of(page - 1, 10, Sort.by("createdAt").descending());
            } else if (sortType.equals("like")) {
                pageRequest = PageRequest.of(page - 1, 10, Sort.by("likeCnt").descending());
            } else if (sortType.equals("comment")) {
                pageRequest = PageRequest.of(page - 1, 10, Sort.by("commentCnt").descending());
            }
        }

        model.addAttribute("category", category);
        model.addAttribute("boards", boardService.getBoardList(boardCategory, pageRequest, searchType, keyword));
        model.addAttribute("boardSearchRequest", new BoardSearchRequest(sortType, searchType, keyword));
        return "boards/list";
    }

    @GetMapping("/{category}/write")
    public String boardWritePage(@PathVariable String category, Model model) {
        BoardCategory boardCategory = BoardCategory.of(category);
        if (boardCategory == null) {
            model.addAttribute("message", "카테고리가 존재하지 않습니다.");
            model.addAttribute("nextUrl", "/");
            return "printMessage";
        }

        model.addAttribute("category", category);
        model.addAttribute("boardCreateRequest", new BoardCreateRequest());
        return "boards/write";
    }

    @PostMapping("/{category}")
    public String boardWrite(@PathVariable String category, @ModelAttribute BoardCreateRequest req,
                             Authentication auth, Model model) throws IOException {
        BoardCategory boardCategory = BoardCategory.of(category);
        if (boardCategory == null) {
            model.addAttribute("message", "카테고리가 존재하지 않습니다.");
            model.addAttribute("nextUrl", "/");
            return "printMessage";
        }

        Long savedBoardId = boardService.writeBoard(req, boardCategory, auth.getName(), auth);
        if (boardCategory.equals(BoardCategory.GREETING)) {
            model.addAttribute("message", "가입인사를 작성하여 SILVER 등급으로 승급했습니다!\n이제 자유게시판에 글을 작성할 수 있습니다!");
        } else {
            model.addAttribute("message", savedBoardId + "번 글이 등록되었습니다.");
        }
        model.addAttribute("nextUrl", "/boards/" + category + "/" + savedBoardId);
        return "printMessage";
    }

    @GetMapping("/{category}/{boardId}")
    public String boardDetailPage(@PathVariable String category, @PathVariable Long boardId, Model model,
                                  Authentication auth) {
        if (auth != null) {
            model.addAttribute("loginUserLoginId", auth.getName());
            model.addAttribute("likeCheck", likeService.checkLike(auth.getName(), boardId));
        }

        BoardDto boardDto = boardService.getBoard(boardId, category);
        // id에 해당하는 게시글이 없거나 카테고리가 일치하지 않는 경우
        if (boardDto == null) {
            model.addAttribute("message", "해당 게시글이 존재하지 않습니다");
            model.addAttribute("nextUrl", "/boards/" + category);
            return "printMessage";
        }

        model.addAttribute("boardDto", boardDto);
        model.addAttribute("category", category);

        model.addAttribute("commentCreateRequest", new CommentCreateRequest());
        model.addAttribute("commentList", commentService.findAll(boardId));
        return "boards/detail";
    }

    @PostMapping("/{category}/{boardId}/edit")
    public String boardEdit(@PathVariable String category, @PathVariable Long boardId,
                            @ModelAttribute BoardDto dto, Model model) throws IOException {
        Long editedBoardId = boardService.editBoard(boardId, category, dto);

        if (editedBoardId == null) {
            model.addAttribute("message", "해당 게시글이 존재하지 않습니다.");
            model.addAttribute("nextUrl", "/boards/" + category);
        } else {
            model.addAttribute("message", editedBoardId + "번 글이 수정되었습니다.");
            model.addAttribute("nextUrl", "/boards/" + category + "/" + boardId);
        }
        return "printMessage";
    }

    @GetMapping("/{category}/{boardId}/delete")
    public String boardDelete(@PathVariable String category, @PathVariable Long boardId, Model model) throws IOException {
        if (category.equals("greeting")) {
            model.addAttribute("message", "가입인사는 삭제할 수 없습니다.");
            model.addAttribute("nextUrl", "/boards/greeting");
            return "printMessage";
        }

        Long deletedBoardId = boardService.deleteBoard(boardId, category);

        // id에 해당하는 게시글이 없거나 카테고리가 일치하지 않으면 에러 메세지 출력
        // 게시글이 존재해 삭제했으면 삭제 완료 메세지 출력
        model.addAttribute("message", deletedBoardId == null ? "해당 게시글이 존재하지 않습니다" : deletedBoardId + "번 글이 삭제되었습니다.");
        model.addAttribute("nextUrl", "/boards/" + category);
        return "printMessage";
    }

    @ResponseBody
    @GetMapping("/images/{filename}")
    public Resource showImage(@PathVariable String filename) throws MalformedURLException {
        return new UrlResource("file:" + uploadImageService.getFullPath(filename));
    }

    @GetMapping("/images/download/{boardId}")
    public ResponseEntity<UrlResource> downloadImage(@PathVariable Long boardId) throws MalformedURLException {
        return uploadImageService.downloadImage(boardId);
    }
}

Board 관련 DTO

BoardCreateRequest

Board를 입력받아 DB에 저장할 때 사용하는 DTO

@Data
public class BoardCreateRequest {

    private String title;
    private String body;
    private MultipartFile uploadImage;

    public Board toEntity(BoardCategory category, User user) {
        return Board.builder()
                .user(user)
                .category(category)
                .title(title)
                .body(body)
                .likeCnt(0)
                .commentCnt(0)
                .build();
    }
}

BoardSearchRequest

게시글 리스트에서 검색할 때 사용하는 DTO

@Data
@AllArgsConstructor
public class BoardSearchRequest {

    private String sortType;
    private String searchType;
    private String keyword;
}

BoardDto

게시글 조회, 리스트 조회, 수정 등에 사용되는 DTO

@Data
@Builder
public class BoardDto {

    private Long id;
    private String userLoginId;
    private String userNickname;
    private String title;
    private String body;
    private Integer likeCnt;
    private LocalDateTime createdAt;
    private LocalDateTime lastModifiedAt;
    private MultipartFile newImage;
    private UploadImage uploadImage;

    public static BoardDto of(Board board) {
        return BoardDto.builder()
                .id(board.getId())
                .userLoginId(board.getUser().getLoginId())
                .userNickname(board.getUser().getNickname())
                .title(board.getTitle())
                .body(board.getBody())
                .createdAt(board.getCreatedAt())
                .lastModifiedAt(board.getLastModifiedAt())
                .likeCnt(board.getLikes().size())
                .uploadImage(board.getUploadImage())
                .build();
    }
}

BoardCntDto

홈 화면에서 각각의 카테고리에 해당하는 Board 수를 출력하기 위해 사용되는 DTO

@Data
@Builder
public class BoardCntDto {

    private Long totalNoticeCnt;
    private Long totalBoardCnt;
    private Long totalGreetingCnt;
    private Long totalFreeCnt;
    private Long totalGoldCnt;
}

[Spring Boot] 게시판 만들기 3 - 유저 기능

chb2005 — Mon, 17 Apr 2023 16:01:51 +0900

유저 기능

회원가입, 로그인, 정보 수정, 회원 탈퇴, 마이 페이지
자세한 기능 설계는 [Spring Boot] 게시판 만들기 1 - 설계 & 결과 참고

UserRepository

findAllByNicknameContains() : 닉네임에 String이 포함되어 있는지 => ADMIN이 User 검색 시 사용
existsByLoginId(), existsByNickname() : 로그인 아이디, 닉네임을 가진 유저가 존재하는지 => 회원 가입 시 중복 체크용으로 사용
countAllByUserRole() : 해당 등급을 가진 유저가 몇명 있는지 => 홈 화면에서 출력하기 위해 사용

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByLoginId(String loginId);
    Page<User> findAllByNicknameContains(String nickname, PageRequest pageRequest);
    Boolean existsByLoginId(String loginId);
    Boolean existsByNickname(String nickname);
    Long countAllByUserRole(UserRole userRole);
}

UserService

joinValid(), editValid()는 회원 가입, 정보 수정 시 비어있는지, 글자수가 초과하는지, 중복되는지 등을 상황과 변수에 맞게 판단 후 하나라도 조건을 만족하지 못하면 BindingResult를 return 함으로써 회원가입, 정보 수정을 못하게 함
delete()는 유저를 삭제하는 메소드인데, DB에서 삭제하기 전 해당 유저가 추가한 댓글, 좋아요를 조회하여 Board의 likeCnt, commentCnt를 직접 수정

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;
    private final LikeRepository likeRepository;
    private final CommentRepository commentRepository;
    private final BCryptPasswordEncoder encoder;

    public BindingResult joinValid(UserJoinRequest req, BindingResult bindingResult)
    {
        if (req.getLoginId().isEmpty()) {
            bindingResult.addError(new FieldError("req", "loginId", "아이디가 비어있습니다."));
        } else if (req.getLoginId().length() > 10) {
            bindingResult.addError(new FieldError("req", "loginId", "아이디가 10자가 넘습니다."));
        } else if (userRepository.existsByLoginId(req.getLoginId())) {
            bindingResult.addError(new FieldError("req", "loginId", "아이디가 중복됩니다."));
        }

        if (req.getPassword().isEmpty()) {
            bindingResult.addError(new FieldError("req", "password", "비밀번호가 비어있습니다."));
        }

        if (!req.getPassword().equals(req.getPasswordCheck())) {
            bindingResult.addError(new FieldError("req", "passwordCheck", "비밀번호가 일치하지 않습니다."));
        }

        if (req.getNickname().isEmpty()) {
            bindingResult.addError(new FieldError("req", "nickname", "닉네임이 비어있습니다."));
        } else if (req.getNickname().length() > 10) {
            bindingResult.addError(new FieldError("req", "nickname", "닉네임이 10자가 넘습니다."));
        } else if (userRepository.existsByNickname(req.getNickname())) {
            bindingResult.addError(new FieldError("req", "nickname", "닉네임이 중복됩니다."));
        }

        return bindingResult;
    }

    public void join(UserJoinRequest req) {
        userRepository.save(req.toEntity( encoder.encode(req.getPassword()) ));
    }

    public User myInfo(String loginId) {
        return userRepository.findByLoginId(loginId).get();
    }

    public BindingResult editValid(UserDto dto, BindingResult bindingResult, String loginId)
    {
        User loginUser = userRepository.findByLoginId(loginId).get();

        if (dto.getNowPassword().isEmpty()) {
            bindingResult.addError(new FieldError("dto", "nowPassword", "현재 비밀번호가 비어있습니다."));
        } else if (!encoder.matches(dto.getNowPassword(), loginUser.getPassword())) {
            bindingResult.addError(new FieldError("dto", "nowPassword", "현재 비밀번호가 틀렸습니다."));
        }

        if (!dto.getNewPassword().equals(dto.getNewPasswordCheck())) {
            bindingResult.addError(new FieldError("dto", "newPasswordCheck", "비밀번호가 일치하지 않습니다."));
        }

        if (dto.getNickname().isEmpty()) {
            bindingResult.addError(new FieldError("dto", "nickname", "닉네임이 비어있습니다."));
        } else if (dto.getNickname().length() > 10) {
            bindingResult.addError(new FieldError("dto", "nickname", "닉네임이 10자가 넘습니다."));
        } else if (!dto.getNickname().equals(loginUser.getNickname()) && userRepository.existsByNickname(dto.getNickname())) {
            bindingResult.addError(new FieldError("dto", "nickname", "닉네임이 중복됩니다."));
        }

        return bindingResult;
    }

    @Transactional
    public void edit(UserDto dto, String loginId) {
        User loginUser = userRepository.findByLoginId(loginId).get();

        if (dto.getNewPassword().equals("")) {
            loginUser.edit(loginUser.getPassword(), dto.getNickname());
        } else {
            loginUser.edit(encoder.encode(dto.getNewPassword()), dto.getNickname());
        }
    }

    @Transactional
    public Boolean delete(String loginId, String nowPassword) {
        User loginUser = userRepository.findByLoginId(loginId).get();

        if (encoder.matches(nowPassword, loginUser.getPassword())) {
            List<Like> likes = likeRepository.findAllByUserLoginId(loginId);
            for (Like like : likes) {
                like.getBoard().likeChange( like.getBoard().getLikeCnt() - 1 );
            }

            List<Comment> comments = commentRepository.findAllByUserLoginId(loginId);
            for (Comment comment : comments) {
                comment.getBoard().commentChange( comment.getBoard().getCommentCnt() - 1 );
            }

            userRepository.delete(loginUser);
            return true;
        } else {
            return false;
        }
    }

    public Page<User> findAllByNickname(String keyword, PageRequest pageRequest) {
        return userRepository.findAllByNicknameContains(keyword, pageRequest);
    }

    @Transactional
    public void changeRole(Long userId) {
        User user = userRepository.findById(userId).get();
        user.changeRole();
    }

    public UserCntDto getUserCnt() {
        return UserCntDto.builder()
                .totalUserCnt(userRepository.count())
                .totalAdminCnt(userRepository.countAllByUserRole(UserRole.ADMIN))
                .totalBronzeCnt(userRepository.countAllByUserRole(UserRole.BRONZE))
                .totalSilverCnt(userRepository.countAllByUserRole(UserRole.SILVER))
                .totalGoldCnt(userRepository.countAllByUserRole(UserRole.GOLD))
                .totalBlacklistCnt(userRepository.countAllByUserRole(UserRole.BLACKLIST))
                .build();
    }
}

UserController

로그인 페이지 접속 시 이전 페이지를 세션에 저장함으로써, 로그인에 성공하면 이전 페이지로 이동시켜 줌
/users/myPage/{category}는 마이 페이지에서 내가 작성한 글, 내가 댓글을 단 글, 내가 좋아요 누른 글을 볼 수 있는데, 이 때 {category}로 분류하여 리스트를 return
/users/admin은 관리자 페이지 => 모든 유저의 정보를 확인 할 수 있음
/users/admin/{userId}는 관리자가 userId에 해당하는 유저의 등급을 변경할 때 사용
"printMessage"는 message에 해당 하는 값을 출력하고, nextUrl에 해당 하는 URL로 이동시켜 주는 HTML 파일

@Controller
@RequiredArgsConstructor
@RequestMapping("/users")
public class UserController {

    private final UserService userService;
    private final BoardService boardService;

    @GetMapping("/join")
    public String joinPage(Model model) {
        model.addAttribute("userJoinRequest", new UserJoinRequest());
        return "users/join";
    }

    @PostMapping("/join")
    public String join(@Valid @ModelAttribute UserJoinRequest req, BindingResult bindingResult, Model model) {

        // Validation
        if (userService.joinValid(req, bindingResult).hasErrors()) {
            return "users/join";
        }

        userService.join(req);
        model.addAttribute("message", "회원가입에 성공했습니다!\n로그인 후 사용 가능합니다!");
        model.addAttribute("nextUrl", "/users/login");
        return "printMessage";
    }

    @GetMapping("/login")
    public String loginPage(Model model, HttpServletRequest request) {

        // 로그인 성공 시 이전 페이지로 redirect 되게 하기 위해 세션에 저장
        String uri = request.getHeader("Referer");
        if (uri != null && !uri.contains("/login") && !uri.contains("/join")) {
            request.getSession().setAttribute("prevPage", uri);
        }

        model.addAttribute("userLoginRequest", new UserLoginRequest());
        return "users/login";
    }

    @GetMapping("/myPage/{category}")
    public String myPage(@PathVariable String category, Authentication auth, Model model) {
        model.addAttribute("boards", boardService.findMyBoard(category, auth.getName()));
        model.addAttribute("category", category);
        model.addAttribute("user", userService.myInfo(auth.getName()));
        return "users/myPage";
    }

    @GetMapping("/edit")
    public String userEditPage(Authentication auth, Model model) {
        User user = userService.myInfo(auth.getName());
        model.addAttribute("userDto", UserDto.of(user));
        return "users/edit";
    }

    @PostMapping("/edit")
    public String userEdit(@Valid @ModelAttribute UserDto dto, BindingResult bindingResult,
                           Authentication auth, Model model) {

        // Validation
        if (userService.editValid(dto, bindingResult, auth.getName()).hasErrors()) {
            return "users/edit";
        }

        userService.edit(dto, auth.getName());

        model.addAttribute("message", "정보가 수정되었습니다.");
        model.addAttribute("nextUrl", "/users/myPage/board");
        return "printMessage";
    }

    @GetMapping("/delete")
    public String userDeletePage(Authentication auth, Model model) {
        User user = userService.myInfo(auth.getName());
        model.addAttribute("userDto", UserDto.of(user));
        return "users/delete";
    }

    @PostMapping("/delete")
    public String userDelete(@ModelAttribute UserDto dto, Authentication auth, Model model) {
        Boolean deleteSuccess = userService.delete(auth.getName(), dto.getNowPassword());
        if (deleteSuccess) {
            model.addAttribute("message", "탈퇴 되었습니다.");
            model.addAttribute("nextUrl", "/users/logout");
            return "printMessage";
        } else {
            model.addAttribute("message", "현재 비밀번호가 틀려 탈퇴에 실패하였습니다.");
            model.addAttribute("nextUrl", "/users/delete");
            return "printMessage";
        }
    }

    @GetMapping("/admin")
    public String adminPage(@RequestParam(required = false, defaultValue = "1") int page,
                            @RequestParam(required = false, defaultValue = "") String keyword,
                            Model model) {

        PageRequest pageRequest = PageRequest.of(page - 1, 10, Sort.by("id").descending());
        Page<User> users = userService.findAllByNickname(keyword, pageRequest);

        model.addAttribute("users", users);
        model.addAttribute("keyword", keyword);
        return "users/admin";
    }

    @GetMapping("/admin/{userId}")
    public String adminChangeRole(@PathVariable Long userId,
                                  @RequestParam(required = false, defaultValue = "1") int page,
                                  @RequestParam(required = false, defaultValue = "") String keyword) throws UnsupportedEncodingException {
        userService.changeRole(userId);
        return "redirect:/users/admin?page=" + page + "&keyword=" + URLEncoder.encode(keyword, "UTF-8");
    }

}

User 관련 DTO

UserJoinRequest

회원가입 시 사용되는 DTO

@Data
public class UserJoinRequest {

    private String loginId;
    private String password;
    private String passwordCheck;
    private String nickname;

    public User toEntity(String encodedPassword) {
        return User.builder()
                .loginId(loginId)
                .password(encodedPassword)
                .nickname(nickname)
                .userRole(UserRole.BRONZE)
                .createdAt(LocalDateTime.now())
                .receivedLikeCnt(0)
                .build();
    }
}

UserLoginRequest

로그인 시 사용되는 DTO

@Data
public class UserLoginRequest {

    private String loginId;
    private String password;
}

UserDto

정보 수정, 탈퇴 등에 사용되는 DTO

@Data
@Builder
public class UserDto {

    private String loginId;
    private String nickname;
    private String nowPassword;
    private String newPassword;
    private String newPasswordCheck;

    public static UserDto of(User user) {
        return UserDto.builder()
                .loginId(user.getLoginId())
                .nickname(user.getNickname())
                .build();
    }
}

UserCntDto

홈 화면에서 각각의 등급에 해당하는 User 수를 출력하기 위해 사용되는 DTO

@Data
@Builder
public class UserDto {

    private String loginId;
    private String nickname;
    private String nowPassword;
    private String newPassword;
    private String newPasswordCheck;

    public static UserDto of(User user) {
        return UserDto.builder()
                .loginId(user.getLoginId())
                .nickname(user.getNickname())
                .build();
    }
}

Spring Security

로그인, 로그아웃, 인증, 인가 등은 Spring Security 사용 => UserDetail, UserDetailService는 [Spring Boot] Spring Security를 사용한 로그인 구현 (Form Login) 참고

BCryptPasswordEncoder

비밀번호 암호화 및 암호화 된 비밀번호와 일치하는지 확인하는데 사용

@Configuration
@EnableWebSecurity
public class EncrypterConfig {

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

Security Config

antMatchers().anonymous() => 로그인하지 않은 유저들만 접근 가능
antMatchers().authenticated() => 로그인 한 유저들만 접근 가능
antMatchers().hasAnyAuthority() => 설정한 등급의 유저들만 접근 가능
인증에 실패한 경우 MyAuthenticationEntryPoint, 인가에 실패한 경우 MyAccessDeniedHandler, 로그인에 성공한 경우 MyLoginSuccessHandler, 로그아웃에 성공한 경우 MyLogoutSuccessHandler 호출

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final UserRepository userRepository;

    // 로그인하지 않은 유저들만 접근 가능한 URL
    private static final String[] anonymousUserUrl = {"/users/login", "/users/join"};

    // 로그인한 유저들만 접근 가능한 URL
    private static final String[] authenticatedUserUrl = {"/boards/**/**/edit", "/boards/**/**/delete", "/likes/**", "/users/myPage/**", "/users/edit", "/users/delete"};

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception {
        return httpSecurity
                .csrf().disable()
                .cors().and()
                .authorizeRequests()
                .antMatchers(anonymousUserUrl).anonymous()
                .antMatchers(authenticatedUserUrl).authenticated()
                .antMatchers("/boards/greeting/write").hasAnyAuthority("BRONZE", "ADMIN")
                .antMatchers(HttpMethod.POST, "/boards/greeting").hasAnyAuthority("BRONZE", "ADMIN")
                .antMatchers("/boards/free/write").hasAnyAuthority("SILVER", "GOLD", "ADMIN")
                .antMatchers(HttpMethod.POST, "/boards/free").hasAnyAuthority("SILVER", "GOLD", "ADMIN")
                .antMatchers("/boards/gold/**").hasAnyAuthority("GOLD", "ADMIN")
                .antMatchers("/users/admin/**").hasAuthority("ADMIN")
                .antMatchers("/comments/**").hasAnyAuthority("BRONZE", "SILVER", "GOLD", "ADMIN")
                .anyRequest().permitAll()
                .and()
                .exceptionHandling()
                .accessDeniedHandler(new MyAccessDeniedHandler(userRepository))           // 인가 실패
                .authenticationEntryPoint(new MyAuthenticationEntryPoint()) // 인증 실패
                .and()
                // 폼 로그인
                .formLogin()
                .loginPage("/users/login")      // 로그인 페이지
                .usernameParameter("loginId")   // 로그인에 사용될 id
                .passwordParameter("password")  // 로그인에 사용될 password
                .failureUrl("/users/login?fail")         // 로그인 실패 시 redirect 될 URL => 실패 메세지 출력
                .successHandler(new MyLoginSuccessHandler(userRepository))    // 로그인 성공 시 실행 될 Handler
                .and()
                // 로그아웃
                .logout()
                .logoutUrl("/users/logout")     // 로그아웃 URL
                .invalidateHttpSession(true).deleteCookies("JSESSIONID")
                .logoutSuccessHandler(new MyLogoutSuccessHandler())
                .and()
                .build();
    }
}

인증 실패

인증에 실패한 경우 (로그인하지 않은 유저가 로그인이 필요한 URL에 접근한 경우) MyAuthenticationEntryPoint 호출
HttpServletResponse, PrintWriter을 사용하여 메세지 출력 후 지정한 URL로 이동 시켜줌

public class MyAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        // 메세지 출력 후 홈으로 redirect
        response.setContentType("text/html");
        PrintWriter pw = response.getWriter();
        pw.println("<script>alert('로그인한 유저만 가능합니다!'); location.href='/users/login';</script>");
        pw.flush();
    }
}

인가 실패

인가에 실패한 경우 (일반 유저가 관리자 권한이 필요한 URL에 접근한 경우 등) MyAccessDeniedHandler 호출
인가에 실패한 URL을 통해 어떤 상황인지 파악 후 알맞은 메세지와 다음 페이지를 지정

@AllArgsConstructor
public class MyAccessDeniedHandler implements AccessDeniedHandler {

    private final UserRepository userRepository;
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException {

        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        User loginUser = null;
        if (auth != null) {
            loginUser = userRepository.findByLoginId(auth.getName()).get();
        }
        String requestURI = request.getRequestURI();

        // 로그인한 유저가 login, join을 시도한 경우
        if (requestURI.contains("/users/login") || requestURI.contains("/users/join")) {
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('이미 로그인 되어있습니다!'); location.href='/';</script>");
            pw.flush();
        }
        // 골드게시판은 GOLD, ADMIN만 접근 가능
        else if (requestURI.contains("gold")) {
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('골드 등급 이상의 유저만 접근 가능합니다!'); location.href='/';</script>");
            pw.flush();
        } else  if (loginUser != null && loginUser.getUserRole().equals(UserRole.BLACKLIST)){
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('블랙리스트는 글, 댓글 작성이 불가능합니다.'); location.href='/';</script>");
            pw.flush();
        }
        // BRONZE 등급이 자유게시판에 글을 작성하려는 경우
        else if (requestURI.contains("free/write")) {
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('가입인사 작성 후 작성 가능합니다!'); location.href='/boards/greeting';</script>");
            pw.flush();
        }
        // SILVER 등급 이상이 가입인사를 작성하려는 경우
        else if (requestURI.contains("greeting")) {
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('가입인사는 한 번만 작성 가능합니다!'); location.href='/boards/greeting';</script>");
            pw.flush();
        }
        // ADMIN이 아닌데 관리자 페이지에 접속한 경우
        else if (requestURI.contains("admin")) {
            // 메세지 출력 후 홈으로 redirect
            response.setContentType("text/html");
            PrintWriter pw = response.getWriter();
            pw.println("<script>alert('관리자만 접속 가능합니다!'); location.href='/';</script>");
            pw.flush();

        }
    }
}

로그인 성공

로그인에 성공한 경우 MyLoginSuccessHandler 호출
유저에 맞는 메세지 출력 후 세션의 "prevPage"에 담긴 URL로 이동 시켜줌
- prevPage에는 로그인 하기 전 URL이 저장되어 있음
- 로그인 페이지 접속 시 해당 값 설정

@AllArgsConstructor
public class MyLoginSuccessHandler implements AuthenticationSuccessHandler {

    private final UserRepository userRepository;

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        // 세션 유지 시간 = 3600초
        HttpSession session = request.getSession();
        session.setMaxInactiveInterval(3600);

        User loginUser = userRepository.findByLoginId(authentication.getName()).get();

        // 성공 시 메세지 출력 후 홈 화면으로 redirect
        response.setContentType("text/html");
        PrintWriter pw = response.getWriter();
        if (loginUser.getUserRole().equals(UserRole.BLACKLIST)) {
            pw.println("<script>alert('" + loginUser.getNickname() + "님은 블랙리스트 입니다. 글, 댓글 작성이 불가능합니다.'); location.href='/';</script>");
        } else {
            String prevPage = (String) request.getSession().getAttribute("prevPage");
            if (prevPage != null) {
                pw.println("<script>alert('" + loginUser.getNickname() + "님 반갑습니다!'); location.href='" + prevPage + "';</script>");
            } else {
                pw.println("<script>alert('" + loginUser.getNickname() + "님 반갑습니다!'); location.href='/';</script>");
            }
        }
        pw.flush();
    }
}

로그아웃 성공

로그아웃에 성공한 경우 MyLogoutSuccessHandler 호출
메세지 출력후 홈으로 이동

public class MyLogoutSuccessHandler implements LogoutSuccessHandler {

    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<script>alert('로그아웃 되었습니다.'); location.href='/';</script>");
        out.flush();
    }
}

[Spring Boot] 게시판 만들기 2 - 라이브러리 설치, ERD, Entity 생성

chb2005 — Mon, 17 Apr 2023 05:43:42 +0900

프로젝트에 사용한 라이브러리 설치 (build.gradle)

implementation 'org.springframework.boot:spring-boot-starter-web'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
developmentOnly 'org.springframework.boot:spring-boot-devtools'
testImplementation 'org.springframework.boot:spring-boot-starter-test'

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

// Thymeleaf, Validation
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity5'
implementation 'org.springframework.boot:spring-boot-starter-validation'

// Spring Security
implementation group: 'org.springframework.boot', name: 'spring-boot-starter-security', version: '2.7.5'

ERD

Entity 설명

User

id(primary key), login_id(로그인에 사용되는 아이디), password, nickname, user_role(등급), received_like_cnt(이 유저가 받은 좋아요 수), created_at(가입일)
User은 여러개의 Board를 작성할 수 있음 => User : Board = 1 : N
User은 여러개의 Comment를 작성할 수 있음 => User : Comment = 1 : N
User은 여러개의 좋아요를 추가할 수 있음 => User : Like = 1 : N

Board

id(primary key), title(제목), body(내용), category, like_cnt(이 글이 받은 좋아요 수), comment_cnt(이 글이 받은 댓글 수), created_at(작성일), last_modified_at(최근 수정일)
Board와 Upload Image는 1:1 관계 => Board에 Upload Image의 Id(foreign key)를 넣음 => Board가 연관관계 주인
Board에는 여러개의 Comment가 달릴 수 있음 => Board : Comment = 1 : N
Board에는 여러개의 Like가 추가될 수 있음 => Board : Like = 1 : N

Comment

id(primary key), body(내용), created_at(작성일), last_modified_at(최근 수정일)

Like

Like는 user_id, board_id를 foreign key로 갖는데, user_id는 좋아요를 누른 유저의 아이디이고, board_id는 좋아요가 달린 게시글의 id

Upload Image

id(primary key), original_filename(유저가 업로드한 이미지의 원본 파일명), saved_filename(서버에 저장된 파일명)
원본 파일명으로 파일을 저장하면 파일명이 중복되어 에러가 발생할 수 있음 => 이를 방지하기 위해 서버에는 중복되지 않는 UUID로 파일명을 수정 후 저장

Entity 구현 코드

User

User가 삭제(탈퇴)되면 유저의 Board, Comment, Like 모두 삭제 => orphanrRemoval=true 설정
UserRole에는 @Enumerated(EnumType.STRING)을 설정 => DB에 저장될 때, "BRONZE", "SILVER"와 같이 String 타입으로 저장됨
User Entity에는 rankUp(), likeChange(), edit(), changeRole() 4개의 메소드가 존재
- rankUp() : BRONZE -> SILVER, SILVER -> GOLD로 승급할 때 사용
- likeChange() : 이 유저의 글에 좋아요가 추가되거나, 취소된 경우 유저의 receivedLikeCnt를 계산하여 수정할 때 사용
- edit() : 유저가 수정할 수 있는 nickname, password를 수정할 때 사용
- changeRole() : rankUp()과는 달리 관리자가 이 유저의 등급을 수정할 때 사용, BRONZE -> SILVER -> GOLD -> BLACKLIST -> BRONZE 순으로 변경

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
public class User {

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

    private String loginId;     // 로그인할 때 사용하는 아이디
    private String password;    // 비밀번호
    private String nickname;    // 닉네임
    private LocalDateTime createdAt;    // 가입 시간
    private Integer receivedLikeCnt; // 유저가 받은 좋아요 개수 (본인 제외)

    @Enumerated(EnumType.STRING)
    private UserRole userRole;      // 권한

    @OneToMany(mappedBy = "user", orphanRemoval = true)
    private List<Board> boards;     // 작성글

    @OneToMany(mappedBy = "user", orphanRemoval = true)
    private List<Like> likes;       // 유저가 누른 좋아요

    @OneToMany(mappedBy = "user", orphanRemoval = true)
    private List<Comment> comments; // 댓글

    public void rankUp(UserRole userRole, Authentication auth) {
        this.userRole = userRole;

        // 현재 저장되어 있는 Authentication 수정 => 재로그인 하지 않아도 권한 수정 되기 위함
        List<GrantedAuthority> updatedAuthorities = new ArrayList<>();
        updatedAuthorities.add(new SimpleGrantedAuthority(userRole.name()));
        Authentication newAuth = new UsernamePasswordAuthenticationToken(auth.getPrincipal(), auth.getCredentials(), updatedAuthorities);
        SecurityContextHolder.getContext().setAuthentication(newAuth);
    }

    public void likeChange(Integer receivedLikeCnt) {
        this.receivedLikeCnt = receivedLikeCnt;
        if (this.receivedLikeCnt >= 10 && this.userRole.equals(UserRole.SILVER)) {
            this.userRole = UserRole.GOLD;
        }
    }

    public void edit(String newPassword, String newNickname) {
        this.password = newPassword;
        this.nickname = newNickname;
    }

    public void changeRole() {
        if (userRole.equals(UserRole.BRONZE)) userRole = UserRole.SILVER;
        else if (userRole.equals(UserRole.SILVER)) userRole = UserRole.GOLD;
        else if (userRole.equals(UserRole.GOLD)) userRole = UserRole.BLACKLIST;
        else if (userRole.equals(UserRole.BLACKLIST)) userRole = UserRole.BRONZE;
    }
}

UserRole

public enum UserRole {
    BRONZE, SILVER, GOLD, BLACKLIST, ADMIN;
}

Board

좋아요 수, 댓글 수를 저장한 이유는 리스트에서 정렬할 때 더 빠른 조회를 위해 따로 저장

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
public class Board extends BaseEntity {

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

    private String title;   // 제목
    private String body;    // 본문

    @Enumerated(EnumType.STRING)
    private BoardCategory category; // 카테고리

    @ManyToOne(fetch = FetchType.LAZY)
    private User user;      // 작성자

    @OneToMany(mappedBy = "board", orphanRemoval = true)
    private List<Like> likes;       // 좋아요
    private Integer likeCnt;        // 좋아요 수

    @OneToMany(mappedBy = "board", orphanRemoval = true)
    private List<Comment> comments; // 댓글
    private Integer commentCnt;     // 댓글 수

    @OneToOne(fetch = FetchType.LAZY)
    private UploadImage uploadImage;

    public void update(BoardDto dto) {
        this.title = dto.getTitle();
        this.body = dto.getBody();
    }

    public void likeChange(Integer likeCnt) {
        this.likeCnt = likeCnt;
    }

    public void commentChange(Integer commentCnt) {
        this.commentCnt = commentCnt;
    }

    public void setUploadImage(UploadImage uploadImage) {
        this.uploadImage = uploadImage;
    }

}

BoardCategory

of 메소드를 통해 String 타입의 category를 BoardCategory 타입으로 변환하는 기능 추가

public enum BoardCategory {
    FREE, GREETING, GOLD;

    public static BoardCategory of(String category) {
        if (category.equalsIgnoreCase("free")) return BoardCategory.FREE;
        else if (category.equalsIgnoreCase("greeting")) return BoardCategory.GREETING;
        else if (category.equalsIgnoreCase("gold")) return BoardCategory.GOLD;
        else return null;
    }
}

Comment

댓글은 수정이 가능하기 때문에 update() 메소드 추가

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
public class Comment extends BaseEntity {

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

    private String body;

    @ManyToOne(fetch = FetchType.LAZY)
    private User user;      // 작성자

    @ManyToOne(fetch = FetchType.LAZY)
    private Board board;    // 댓글이 달린 게시판

    public void update(String newBody) {
        this.body = newBody;
    }
}

Like

MySQL에서 Table 명을 like로 사용할 수 없는데, @Table(name = ""like"")를 통해 like로 설정

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
@Table(name = "\"like\"")
public class Like {

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

    @ManyToOne(fetch = FetchType.LAZY)
    private User user;      // 좋아요를 누른 유저

    @ManyToOne(fetch = FetchType.LAZY)
    private Board board;    // 좋아요가 추가된 게시글

}

UploadImage

@Entity
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Getter
public class UploadImage {

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

    private String originalFilename;    // 원본 파일명
    private String savedFilename;        // 서버에 저장된 파일명

    @OneToOne(mappedBy = "uploadImage", fetch = FetchType.LAZY)
    private Board board;

}

BaseEntity

하나의 객체가 DB에 저장될 때, 자동으로 createdAt, lastModifiedAt을 저장하기 위해 사용되는 Entity
아래의 JpaAuditingConfig를 등록하고, Board와 같이 상속시켜 사용

@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public class BaseEntity {

    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime lastModifiedAt;
}

JpaAuditingConfig

@Configuration
@EnableJpaAuditing
public class JpaAuditingConfig {
}