SihoonCho's.log

TypeScript 프로젝트 구조 & 파일 네이밍 컨벤션 (실무 기준 정리)

Tue, 07 Apr 2026 16:32:05 GMT

TypeScript는 Java처럼 “정해진 구조”를 강제하지 않는다. 하지만 실제 프로젝트에서는 일관된 구조와 네이밍 규칙이 필수다. 이 글에서는 공식 개념 + 실무 관례를 기반으로 정리한다.

1. 📌 TypeScript 구조의 핵심: 모듈 시스템

기본 개념

파일 = 모듈

📎 공식 문서 https://www.typescriptlang.org/docs/handbook/2/modules.html

핵심:

import/export가 존재하면 해당 파일은 모듈로 동작한다

Java vs TypeScript

Java	TypeScript
클래스 중심	파일(모듈) 중심
패키지 구조	자유 구조
상속 기반	조합 기반

👉 결론:

TypeScript는 “파일의 역할” 중심으로 구조를 설계해야 한다

2. 📦 실무에서 가장 많이 쓰는 디렉토리 구조

기본 구조

src/
  main.ts
  config/
  modules/
    user/
      user.controller.ts
      user.service.ts
      user.repository.ts
      user.entity.ts
  shared/
    utils/
    errors/

구조 특징

feature-based 구조
도메인 중심 구성
역할별 파일 분리

3. 🗂️ 파일 네이밍 컨벤션 (domain.role)

규칙

..ts

예시

user.controller.ts
user.service.ts
user.repository.ts
user.entity.ts

장점

✔ 역할이 명확함

user.repository.ts → DB 접근
user.service.ts → 비즈니스 로직

✔ 정렬이 직관적

user.controller.ts
user.repository.ts
user.service.ts

✔ 파일명 충돌 방지

user.ts ❌

용어

dot-based naming
role-based naming

4. 🔤 코드 레벨 네이밍 규칙

클래스

export class UserRepository {}

👉 PascalCase

함수 / 변수

const getUser = () => {}
const userName = "john";

👉 camelCase

상수

const MAX_RETRY_COUNT = 3;

👉 UPPER_SNAKE_CASE

타입 / 인터페이스

export interface User {}
type UserStatus = "active" | "inactive";

👉 PascalCase

파일 vs 클래스

대상	예시
파일	user.repository.ts
클래스	UserRepository

🚀 정리

1. 파일 = 모듈 (핵심 개념)
2. 구조는 자유지만 feature 기반이 일반적
3. 파일명은 domain.role 패턴 사용
4. 클래스 PascalCase, 나머지는 camelCase

📎 참고 자료

TypeScript Modules https://www.typescriptlang.org/docs/handbook/2/modules.html
Angular Style Guide https://angular.dev/style-guide
Node.js TypeScript Guide https://nodejs.org/learn/typescript/publishing-a-ts-package

[SpringBoot] 2024 JWT ① - 기본 설정

Wed, 27 Nov 2024 13:42:20 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 제공하고자 작성되었습니다. 실습 중심의 이해를 목표로 작성되었기 때문에, 다소 생략/과장된 설명이 있을 수 있습니다. 따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 유의하시고 양해 부탁드립니다. 또한, Spring Boot 기반의 Backend 개발에 중점을 두고 설명하고 있으므로, Frontend와 관련된 내용은 별도의 참고자료를 검색/활용하실 것을 권장드립니다.

📌 JWT (JSON Web Token)

JWT (JSON Web Token)

JWT(JSON Web Token)는 개방형 웹 표준 RFC 7519로 지정된 JSON 객체 형태의 Web Token으로 Token 자체에 정보를 저장하는 인증 방식입니다.

OAuth, SAML(Security Assertion Markup Language), OpenID Connect 등과 함께 대표적으로 사용되는 인증 방식으로 다른 인증 방식에 비해 가볍고 간편하다는 장점이 있습니다.

- [출처] JWT 공식 홈페이지 -

인증 정보를 담은 Token을 암호화하여 전송

📖 JWT 구조

JWT 구조

Header, Payload, Signature로 구성
- Header: 토큰 타입(typ)과 해싱 알고리즘(alg) 정보를 포함
- Payload: 사용자 인증 정보와 클레임 데이터를 JSON 형식으로 포함
- Signature: Header와 Payload를 특정 비밀키로 서명하여 변조 방지

→ 인증 정보를 담은 Token을 암호화하여 전송

📖 JWT 장단점

장점

빠른 인증 처리 토큰 자체에 정보를 포함하므로, 데이터베이스 조회 없이 인증 가능
토큰 기반 인증 방식 중앙 인증서버 방식, 수평적 시스템 확장성 향상 서버 상태를 유지하지 않아도 되므로 확장성 향상
다양한 플랫폼 지원 표준 규격(JSON)을 사용하여 웹, 모바일, 클라이언트-서버 간 호환성 우수 Base64 URL Safe Encoding을 사용하기 때문에 URL, Cookie, Header 모두 사용 가능

단점

토큰 크기 Payload의 정보가 많아지면, 네트워크 사용량 부담 증가
보안 관리 필요 비밀키가 유출되면 모든 토큰이 위조될 수 있는 위험성 존재
토큰 취소 어려움 토큰은 클라이언트에 저장되므로, 서버에서 토큰을 조작할 수 없음 토큰은 클라이언트에 저장되므로, 발급 후 유효기간 만료 전에 취소하기 어려움

📌 JWT 기본설정

JWT 기본설정

JWT(JSON Web Token)를 이용한 인증 구현을 위해 build.gradle, application.properties를 설정한다.

📖 build.gradle

dependencies {
    // ...
    implementation 'org.springframework.boot:spring-boot-starter-security'    // 추가
    implementation 'io.jsonwebtoken:jjwt-api:0.11.5'      // 추가
    implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'        // 추가
    implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'  // 추가
    testImplementation 'org.springframework.security:spring-security-test'    // 추가
    // ...
}

JJWT (Java JWT)

jjwt 라이브러리는 버전 0.10.0부터 3개로 분리됨
작성일 기준 Maven Repository에서 가장 많이 사용된 최신 버전 0.11.5
- ~~과거 implementation 'io.jsonwebtoken:jjwt:0.9.1'~~
- 현재 implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
- 현재 implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
- 현재 implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'

📖 application.properties

# JWT Settings
jwt.secret=your_secret_key
jwt.access.expiration=3600000       # Access Token Expiration: 1hour (ms)
jwt.refresh.expiration=86400000     # Refresh Token Expiration: 24hour (ms)

application.properties

jwt.secret: 토큰 서명에 사용되는 비밀키 정의 토큰의 유효성을 확인하는 데 필요
jwt.access.expiration: 액세스 토큰의 만료 시간(ms 단위) 일반적으로 짧은 주기로 설정하여 보안 강화
jwt.refresh.expiration: 리프레시 토큰의 만료 시간(ms 단위) 액세스 토큰 갱신을 위해 더 긴 주기로 설정

[SpringBoot] 2024 게시판 만들기 Q&A ⑥ - JPQL, 네이티브 쿼리

Mon, 25 Nov 2024 04:54:06 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 제공하고자 작성되었습니다. 실습 중심의 이해를 목표로 작성되었기 때문에, 다소 과장되거나 생략된 부분이 있을 수 있습니다. 따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 유의하시고 양해 부탁드립니다. 또한, Spring Boot 기반의 Backend 개발에 중점을 두고 설명하고 있으므로, Frontend와 관련된 내용은 별도의 참고자료를 검색/활용하실 것을 권장드립니다.

📌 JPQL

JPQL(Java Persistence Query Language)은 JPA에서 객체(Entity)를 기반으로 데이터를 조회하거나 조작하기 위해 사용하는 쿼리 언어입니다.

SQL과 유사하지만, 테이블 대신 엔티티와 속성을 대상으로 작업합니다.

Raw JPA vs Spring Data JPA

Raw JPA에서는 EntityManager, Spring Data JPA에서는 @Query와 @Param을 활용해 JPQL을 작성하고 실행할 수 있습니다.

Raw JPA의 EntityManager는 JPQL을 직접 작성하여 데이터베이스와 상호작용합
Spring Data JPA에서는 @Query를 사용해 명시적으로 JPQL을 작성하거나, 메서드 이름 기반 쿼리 메서드를 통해 간편하게 JPQL 생성

📖 JPQL 개념

특징

데이터베이스 독립적
테이블이 아닌 클래스와 속성을 기준으로 작성

작동 원리

JPQL 생성: JPA 메서드 호출 시 필요에 따라 내부적으로 JPQL 생성
자동 변환: JPA가 JPQL을 Native SQL로 변환하여 데이터베이스에서 실행
객체 지향 쿼리: 데이터베이스 테이블이 아닌 JPA의 엔티티를 대상으로 작성

JPQL vs Native SQL

JPQL: "SELECT e FROM Employee e WHERE e.name = :name"
Native SQL: "SELECT * FROM employee WHERE name = 'John'"

📖 JPQL 예제코드

✅ 패키지 구조

├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com.companyname.projectname/
│   │   │       ├── post/
│   │   │       │   ├── entity
│   │   │       │   │   └── Post.java
│   │   │       │   ├── repository
│   │   │       │   │   └── PostRepository.java
│   │   │       │   ├── service
│   │   │       │   │   └── PostService.java
│   │   │       │   └── controller
│   │   │       │       └── PostController.java
│   │   │       └── ProjectNameApplication.java
│   │   └── resources
│   └── test

✅ `PostRepository`

package com.companyname.projectname.post.repository;

import com.companyname.projectname.post.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    // Spring Data JPA JPQL (Java Persistence Query Language) 방식
    @Query("SELECT p FROM Post p WHERE p.title = :title")
    List findByTitle(@Param("title") String title);
}

✅ `PostService`

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.entity.Post;
import com.companyname.projectname.post.repository.PostRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostService {

    private final EntityManager entityManager;
    private final PostRepository postRepository;

    // Spring Data JPA JPQL 방식
    public List getPostsByTitle(String title) {
        return postRepository.findByTitle(title);
    }

    // EntityManager JPA JPQL 방식 1
    public List getPostsByTitleJPQL(String title) {
        TypedQuery query = entityManager.createQuery(
            "SELECT p FROM Post p WHERE p.title = :title", Post.class);
        query.setParameter("title", title);
        return query.getResultList();
    }

    // EntityManager JPA JPQL 방식 2
    public List getPostsByTitleJPQL(String title) {
        return entityManager.createQuery(
            "SELECT p FROM Post p WHERE p.title = :title", Post.class)
            .setParameter("title", title)
            .getResultList();
    }
}

✅ `다양한 응용 예시`

package com.companyname.projectname.post.repository;

import com.companyname.projectname.post.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    // Spring Data JPA JPQL (Java Persistence Query Language) 기반 메서드

    // 기본 메서드
    @Query("SELECT p FROM Post p WHERE p.title = :title")
    List findByTitle(@Param("title") String title);
    @Query("SELECT p FROM Post p WHERE p.content = :content")
    List findByContent(@Param("content") String content);
    @Query("SELECT p FROM Post p WHERE p.title LIKE CONCAT('%', :title, '%')")
    List findByTitleContaining(@Param("title") String title);
    @Query("SELECT p FROM Post p WHERE p.content LIKE CONCAT('%', :content, '%')")
    List findByContentContaining(@Param("content") String content);
    @Query("SELECT p FROM Post p WHERE LOWER(p.title) LIKE LOWER(CONCAT('%', :title, '%'))")
    List findByTitleContainingIgnoreCase(@Param("title") String title);
    @Query("SELECT p FROM Post p WHERE LOWER(p.content) LIKE LOWER(CONCAT('%', :content, '%'))")
    List findByContentContainingIgnoreCase(@Param("content") String content);

    // 복합 메서드
    @Query("SELECT p FROM Post p WHERE p.title = :title AND p.content = :content")
    List findByTitleAndContent(@Param("title") String title, @Param("content") String content);
    @Query("SELECT p FROM Post p WHERE p.title LIKE CONCAT('%', :title, '%') OR p.content LIKE CONCAT('%', :content, '%')")
    List findByTitleContainingOrContentContaining(@Param("title") String title, @Param("content") String content);
    @Query("SELECT p FROM Post p WHERE p.title LIKE CONCAT('%', :title, '%') AND p.content LIKE CONCAT('%', :content, '%')")
    List findByTitleContainingAndContentContaining(@Param("title") String title, @Param("content") String content);
    @Query("SELECT p FROM Post p WHERE LOWER(p.title) LIKE LOWER(CONCAT('%', :title, '%')) OR LOWER(p.content) LIKE LOWER(CONCAT('%', :content, '%'))")
    List findByTitleContainingIgnoreCaseOrContentContainingIgnoreCase(@Param("title") String title, @Param("content") String content);
    @Query("SELECT p FROM Post p WHERE LOWER(p.title) LIKE LOWER(CONCAT('%', :title, '%')) AND LOWER(p.content) LIKE LOWER(CONCAT('%', :content, '%'))")
    List findByTitleContainingIgnoreCaseAndContentContainingIgnoreCase(@Param("title") String title, @Param("content") String content);

    // 날짜 기반 메서드 (생성 일자 기준)
    @Query("SELECT p FROM Post p WHERE p.createdDate > :date")
    List findByCreatedDateAfter(@Param("date") LocalDateTime date);
    @Query("SELECT p FROM Post p WHERE p.createdDate < :date")
    List findByCreatedDateBefore(@Param("date") LocalDateTime date);
    @Query("SELECT p FROM Post p WHERE p.createdDate BETWEEN :sDate AND :eDate")
    List findByCreatedDateBetween(@Param("sDate") LocalDateTime sDate, @Param("eDate") LocalDateTime eDate);

    // 날짜 기반 메서드 (수정 일자 기준)
    @Query("SELECT p FROM Post p WHERE p.updatedDate > :date")
    List findByUpdatedDateAfter(@Param("date") LocalDateTime date);
    @Query("SELECT p FROM Post p WHERE p.updatedDate < :date")
    List findByUpdatedDateBefore(@Param("date") LocalDateTime date);
    @Query("SELECT p FROM Post p WHERE p.updatedDate BETWEEN :sDate AND :eDate")
    List findByUpdatedDateBetween(@Param("sDate") LocalDateTime sDate, @Param("eDate") LocalDateTime eDate);
}

📌 Native Query

Native Query는 SQL을 직접 작성하여 실행하는 방법으로, 복잡한 쿼리나 데이터베이스 특정 기능을 사용할 때 유용합니다. JPA는 네이티브 쿼리를 실행해도 결과를 엔티티로 매핑합니다.

Spring Data JPA에서 Native Query를 사용할 수도 있습니다. Spring Data JPA는 작성한 Native SQL을 그대로 데이터베이스에서 실행합니다.

복잡한 쿼리를 사용할 때 편리하지만, 데이터베이스 의존성이 높아질 수 있습니다.

📖 Native Query 개념

특징

리스트로 반환되는 결과나 Pageable의 정렬이 자동으로 적용되지 않습니다.
- Native Query에 ORDER BY를 명시적으로 추가
- Service Layer에서 데이터를 수동으로 정렬 (Java Stream 등 활용)
- 실무에서는 데이터베이스에서 정렬을 처리하는 것이 더 성능이 좋고 효율적

작동 원리

직접 SQL 작성: JPQL 대신 SQL을 직접 작성해 데이터베이스에 명령 전달
데이터베이스 종속적: 특정 DB의 문법을 사용해야 하므로 이식성이 떨어질 수 있음
JPA의 매핑 기능 활용: 결과를 엔티티에 매핑해 객체 지향적 접근 가능

사용 목적

복잡한 SQL을 처리해야 하는 경우
데이터베이스 고유 기능이나 최적화가 필요한 경우

📖 Native Query 예제코드

✅ 패키지 구조

├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com.companyname.projectname/
│   │   │       ├── post/
│   │   │       │   ├── entity
│   │   │       │   │   └── Post.java
│   │   │       │   ├── repository
│   │   │       │   │   └── PostRepository.java
│   │   │       │   ├── service
│   │   │       │   │   └── PostService.java
│   │   │       │   └── controller
│   │   │       │       └── PostController.java
│   │   │       └── ProjectNameApplication.java
│   │   └── resources
│   └── test

✅ PostRepository

package com.companyname.projectname.post.repository;

import com.companyname.projectname.post.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    // Spring Data JPA Native Query 방식
    @Query(value = "SELECT * FROM post WHERE title = :title ORDER BY id ASC", nativeQuery = true)
    List findByTitle(@Param("title") String title);
}

✅ `PostService`

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.entity.Post;
import com.companyname.projectname.post.repository.PostRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostService {

    private final EntityManager entityManager;
    private final PostRepository postRepository;

    // Spring Data JPA Native Query 방식
    public List getPostsByTitle(String title) {
        return postRepository.findByTitle(title);
    }

    // EntityManager JPA Native Query 방식 1
    public List getPostsByTitleJPQL(String title) {
        TypedQuery query = entityManager.createNativeQuery(
            "SELECT * FROM post WHERE title = :title", Post.class);
        query.setParameter("title", title);
        return query.getResultList();
    }

    // EntityManager JPA Native Query 방식 2
    public List getPostsByTitleJPQL(String title) {
        return entityManager.createNativeQuery(
            "SELECT * FROM post WHERE title = :title", Post.class)
            .setParameter("title", title)
            .getResultList();
    }
}

✅ `다양한 응용 예시`

package com.companyname.projectname.post.repository;

import com.companyname.projectname.post.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    // Spring Data JPA Native Query 기반 메서드

    // 기본 메서드
    @Query(value = "SELECT * FROM post WHERE title = :title ORDER BY id ASC", nativeQuery = true)
    List findByTitle(@Param("title") String title);
    @Query(value = "SELECT * FROM post WHERE content = :content ORDER BY id ASC", nativeQuery = true)
    List findByContent(@Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE title LIKE CONCAT('%', :title, '%') ORDER BY id ASC", nativeQuery = true)
    List findByTitleContaining(@Param("title") String title);
    @Query(value = "SELECT * FROM post WHERE content LIKE CONCAT('%', :content, '%') ORDER BY id ASC", nativeQuery = true)
    List findByContentContaining(@Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE LOWER(title) LIKE LOWER(CONCAT('%', :title, '%')) ORDER BY id ASC", nativeQuery = true)
    List findByTitleContainingIgnoreCase(@Param("title") String title);
    @Query(value = "SELECT * FROM post WHERE LOWER(content) LIKE LOWER(CONCAT('%', :content, '%')) ORDER BY id ASC", nativeQuery = true)
    List findByContentContainingIgnoreCase(@Param("content") String content);

    // 복합 메서드
    @Query(value = "SELECT * FROM post WHERE title = :title AND content = :content ORDER BY id ASC", nativeQuery = true)
    List findByTitleAndContent(@Param("title") String title, @Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE title LIKE CONCAT('%', :title, '%') OR content LIKE CONCAT('%', :content, '%') ORDER BY id ASC", nativeQuery = true)
    List findByTitleContainingOrContentContaining(@Param("title") String title, @Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE title LIKE CONCAT('%', :title, '%') AND content LIKE CONCAT('%', :content, '%') ORDER BY id ASC", nativeQuery = true)
    List findByTitleContainingAndContentContaining(@Param("title") String title, @Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE LOWER(title) LIKE LOWER(CONCAT('%', :title, '%')) OR LOWER(content) LIKE LOWER(CONCAT('%', :content, '%')) ORDER BY id ASC", nativeQuery = true)
    List findByTitleContainingIgnoreCaseOrContentContainingIgnoreCase(@Param("title") String title, @Param("content") String content);
    @Query(value = "SELECT * FROM post WHERE LOWER(title) LIKE LOWER(CONCAT('%', :title, '%')) AND LOWER(content) LIKE LOWER(CONCAT('%', :content, '%')) ORDER BY id ASC", nativeQuery = true)
    List findByTitleContainingIgnoreCaseAndContentContainingIgnoreCase(@Param("title") String title, @Param("content") String content);

    // 날짜 기반 메서드 (생성 일자 기준)
    @Query(value = "SELECT * FROM post WHERE created_date > :date ORDER BY id ASC", nativeQuery = true)
    List findByCreatedDateAfter(@Param("date") LocalDateTime date);
    @Query(value = "SELECT * FROM post WHERE created_date < :date ORDER BY id ASC", nativeQuery = true)
    List findByCreatedDateBefore(@Param("date") LocalDateTime date);
    @Query(value = "SELECT * FROM post WHERE created_date BETWEEN :sDate AND :eDate ORDER BY id ASC", nativeQuery = true)
    List findByCreatedDateBetween(@Param("sDate") LocalDateTime sDate, @Param("eDate") LocalDateTime eDate);

    // 날짜 기반 메서드 (수정 일자 기준)
    @Query(value = "SELECT * FROM post WHERE updated_date > :date ORDER BY id ASC", nativeQuery = true)
    List findByUpdatedDateAfter(@Param("date") LocalDateTime date);
    @Query(value = "SELECT * FROM post WHERE updated_date < :date ORDER BY id ASC", nativeQuery = true)
    List findByUpdatedDateBefore(@Param("date") LocalDateTime date);
    @Query(value = "SELECT * FROM post WHERE updated_date BETWEEN :sDate AND :eDate ORDER BY id ASC", nativeQuery = true)
    List findByUpdatedDateBetween(@Param("sDate") LocalDateTime sDate, @Param("eDate") LocalDateTime eDate);
}

📌 JPA vs JPQL vs Native Query

📖 JPA

@Repository
public interface PostRepository extends JpaRepository {
    List findByTitle(String title);
}

📖 JPQL

@Repository
public interface PostRepository extends JpaRepository {
    @Query("SELECT p FROM Post p WHERE p.title = :title")
    List findByTitle(@Param("title") String title);
}

📖 Native Query

@Repository
public interface PostRepository extends JpaRepository {
    @Query(value = "SELECT * FROM post WHERE title = :title ORDER BY id ASC", nativeQuery = true)
    List findByTitle(@Param("title") String title);
}

차이점 정리

JPQL : "SELECT p FROM Post p WHERE p.title = :title"
Native SQL : "SELECT * FROM post WHERE title = :title"

[SpringBoot] 2024 게시판 만들기 Q&A ⑤ - Spring Data JPA

Sun, 24 Nov 2024 07:37:47 GMT

※ 읽기에 앞서

📌 JPA

JPA(Java Persistence API)는, Java 애플리케이션에서 데이터베이스 작업을 간소화하기 위해 제공되는 ORM(Object-Relational Mapping) 기술 표준입니다. JPA를 활용하면 객체 지향 프로그래밍 방식으로 데이터베이스를 다룰 수 있어 개발 생산성과 코드의 가독성이 크게 향상됩니다.

📖 JPA 개념

ORM(Object-Relational Mapping)

객체와 데이터베이스 테이블 간의 매핑을 자동으로 처리
SQL을 직접 작성하지 않고도 객체를 사용해 데이터베이스 작업 가능

JPA(Java Persistence API)

JPA는 인터페이스 기반의 표준 사양으로, Hibernate 같은 구현체를 사용해 동작
데이터베이스와의 연결, CRUD 작업, 쿼리 작성 등을 간편하게 처리

📌 Spring Data JPA

Spring Framework에서 흔히 사용하는 Spring Data JPA는 Spring Framework와 JPA를 통합하여 데이터베이스 작업을 더 간단하게 처리할 수 있도록 도와주는 라이브러리 모듈입니다.

📖 Spring Data JPA 개념

인터페이스만 정의하면 기본적인 CRUD 기능이 자동으로 구현되며, @Query를 사용해 복잡한 JPQL이나 Native Query도 지원합니다. JPA의 강력한 기능을 Spring 환경에서 쉽게 활용할 수 있으며, 생산성을 크게 향상시킵니다.

📖 Spring Data JPA 동작 원리

Spring Data JPA의 메서드 호출은 상황에 따라 JPQL을 생성합니다. 이후, 다시 Native SQL로 변환되어 데이터베이스에서 실행됩니다.

Spring Data JPA 동작 과정

메서드 호출
JPQL 생성
- JPQL 생성이 필요한 경우
  - findByName(String name) 같은 쿼리 메서드는 JPA가 내부적으로 JPQL 생성
- JPQL 생성이 필요하지 않은 경우
  - find(), save(), delete() 같은 기본 메서드는 바로 Native SQL 생성
  - JPQL을 명시적으로 작성한 경우 JPA가 이를 직접 Native SQL로 변환
JPQL을 Native SQL로 변환
Native SQL 데이터베이스에 전달 및 실행
SQL 실행 결과를 다시 JPA 엔티티 객체로 매핑하여 반환

📌 결론

JPA는 기본적으로 Native SQL을 실행하기 위한 도구입니다. JPQL은 Native SQL을 생성하기 위한 중간 단계로 사용됩니다.

그러나, JPA의 메서드 호출이 항상 JPQL을 생성하는 것은 아닙니다. 상황에 따라 바로 Native SQL로 변환하거나 생성하기도 합니다.

Spring Data JPA에서 일반적인 메서드를 호출하는 경우 JPQL이 생성될 수 있습니다. 그러나, JPA의 기본 메서드 find(), save(), delete() 등을 호출하는 경우 JPQL 생성 없이 바로 Native SQL을 생성하거나, 명시적인 JPQL을 작성하는 경우 바로 Native SQL로 변환되어 데이터베이스에서 실행됩니다.

Spring Data JPA의 전체 과정은 아래와 같이 요약할 수 있습니다

정리하면, JPA는 메서드를 호출하면 필요에 따라 내부적으로 JPQL로 변환한 뒤, 이를 다시 Native SQL로 변환해서 데이터베이스에서 실행합니다.

메서드 호출 → (필요 시) JPQL 생성 → Native SQL 변환 → SQL 실행 → 결과를 객체로 매핑

📖 JPA 장단점

JPA 장점

생산성향상: SQL 작성 부담을 줄이고, 객체 중심의 개발 가능
유지보수성: 데이터베이스 변경 시, 객체 중심의 수정으로 유지보수 용이
성능최적화: 지연 로딩, 캐싱, 배치 처리 등 성능 최적화 지원
DB 독립성: 데이터베이스에 종속되지 않는 애플리케이션 개발 가능

JPA 단점

학습 곡선: 객체와 데이터베이스 간 매핑 개념 이해 필요
처리 한계: 복잡한 SQL이 필요한 경우 JPQL, Native Query 사용
초기 설정: 초기 설정 방법이 다소 복잡
- ex) persistence.xml, Spring Data JPA 설정 등

📖 JPA를 사용해야 하는가?

JPA는 객체 지향과 데이터베이스의 간극을 메우는 강력한 기술입니다. Java 개발자에게 JPA는 생산성과 객체 지향 설계의 조화를 제공하는 강력한 도구입니다. 특히, Spring Boot, Spring Data JPA를 통해 CRUD 작업, Repository 패턴 쉽게 구현할 수 있습니다.

처음에는 조금 복잡하게 느껴질 수 있지만, 프로젝트 규모가 커질수록 그 가치를 실감할 수 있습니다. Java로 데이터베이스 작업을 한다면, JPA는 선택이 아닌 필수라고 할 수 있습니다.

반복적인 CRUD SQL 작성과 객체를 SQL에 Mapping하는데 시간을 보내기에는, 개발자의 시간이 너무 아깝습니다. 이미 많은 Java 개발자들이 오랫동안 비슷한 고민을 해왔으며, 이 문제를 해결하기 위해 많은 노력을 기울여왔습니다. 그리고 그 노력의 결정체가 바로 JPA입니다.

JPA는 표준 명세만 570 페이지에 달하며, JPA를 구현한 Hibernate는 10년 이상 지속적으로 개발되고 있고, 핵심 모듈의 코드가 이미 10만 줄을 넘어섰습니다. 귀찮은 문제들은 이제 JPA에게 맡기고, 더 좋은 객체 모델링과 더 많은 테스트를 작성하는데 개발자의 시간을 보내세요.

개발자는 SQL Mapper가 아닙니다.

- 출처: 자바 ORM 표준 JPA 프로그래밍 / 저자: 김영한 -

[SpringBoot] 2024 게시판 만들기 Q&A ④ - @Builder 빌더 패턴

Sat, 23 Nov 2024 13:41:33 GMT

※ 읽기에 앞서

📌 @Builder 빌더 패턴

Lombok의 @Builder 어노테이션은 객체를 빌더 패턴으로 생성할 수 있게 도와줍니다. 클래스와 생성자 중 @Builder를 어디에 붙이는지에 따라 중요한 차이가 있습니다. 다음은 두 방식의 차이점입니다.

📖 1. 클래스에 @Builder를 붙이는 경우

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email;
}

// 사용 예시
User user = User.builder()
    .name("John Doe")
    .age(30)
    .email("john.doe@example.com")
    .build();

// 출력: User(name=John Doe, age=30, email=john.doe@example.com)
System.out.println(user);

기본적으로 @AllArgsConstructor를 활용하여 빌더가 객체 생성
클래스의 모든 필드(멤버 변수)를 대상으로 빌더 생성
클래스의 필드(멤버 변수)가 많을 때 유용

클래스에 @Builder를 사용하는 경우, 모든 필드(멤버 변수)를 포함하는 빌더가 생성됩니다.

📖 2. 생성자에 @Builder를 붙이는 경우

import lombok.Builder;
import lombok.ToString;

@ToString
public class User {
    private String name;
    private int age;
    private String email;

    @Builder
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
}

// 사용 예시
User user = User.builder()
    .name("John Doe")
    .email("john.doe@example.com")
    .build();

// 출력: User(name=John Doe, age=0, email=john.doe@example.com)
System.out.println(user);

기본적으로 @AllArgsConstructor를 활용하여 빌더가 객체를 생성하므로, 이를 이용해 제한된 필드로 객체 생성
생성자에 포함된 필드(매개변수)만을 대상으로 빌더 생성
클래스의 일부 필드(멤버 변수)만 초기화하려는 경우 적합

생성자에 @Builder를 사용하는 경우, 해당 생성자의 매개변수만을 포함하는 빌더가 생성됩니다. 위 예제에서 age는 생성자의 매개변수에 포함되지 않았으므로 빌더로 초기화되지 않습니다. age는 기본값인 0으로 설정됩니다.

📌 차이점 요약

@Builder를 클래스에 사용하는 경우

비교적 코드 간결
클래스의 모든 필드 포함
모든 필드의 초기화가 필요한 경우 적합

@Builder를 생성자에 사용하는 경우

생성자 추가 작성이 필요하므로 비교적 코드가 간결하지 않음
생성자의 매개변수에 해당하는 필드만 포함
특정 필드만 초기화가 필요하거나, 여러 생성자를 구분하는 경우 적합

[SpringBoot] 2024 게시판 만들기 Q&A ② - 데이터의 흐름

Sat, 23 Nov 2024 05:47:23 GMT

※ 읽기에 앞서

📌 데이터의 흐름

실습에 앞서 데이터의 흐름을 알아야 합니다.

├── domain(model) ├── dto ├── repository ├── service ├── controller

아, 벌써부터 머리가 막 어지럽고 인터넷 창을 닫고싶어집니다. 그러니 여러분을 위해 이게 의미하는 바를 간단히 요약해보겠습니다.

📖 데이터의 흐름

데이터의 흐름은 아래의 순서를 거친다. DB(domain) -> repository -> service -> dto -> controller DB(domain) <- repository <- service <- dto <- controller

엄밀히 말하면 domain은 DB가 아니라, 테이블 정의입니다. 편의상 기억하기 좋고 이해를 돕기 위해 저렇게 분류를 해두었습니다.

간단히 정리하면 아래의 핵심만 기억하면 됩니다.

Service 단을 거칠 때, Entity가 Dto로 변환(복사)된다.

또 다시 의문이 생깁니다.

"그래서 Entity는 뭐고 DTO는 뭔데?!"

📖 Entity vs DTO

Entity: 실제 DB에 저장된 데이터 하나 하나를 의미하는 단위 DTO: 실제 데이터인 Entity를 필요한 속성만 뽑아 복사한 데이터

그러니까 정리하면 Service 단을 거칠 때 데이터를 복사하여 전달하겠다는 것입니다.

"왜 번거롭게 DTO로 복사를 하지? 그냥 Entity를 바로 가져다 쓰면 안 돼?!"

개발을 좀 공부해보셨다면 '은행원 알고리즘' 문제를 아실겁니다. 'A가 입금하는 동안, B가 출금하면, 최종잔고에 문제가 생긴다.' 라는 것인데, 물론 Entity로 처리하더라도 은행원 알고리즘이 완벽하면 문제는 없습니다.

하지만, 이런 비슷한 다른 문제가 발생한다면? 실제로 개발을 진행했을 때 이런 문제가 발생하면 오류가 난 상태로 DB에 저장됩니다.

만약 결제 시스템이나 핀테크 기능이었다면 실제로 금전문제가 발생할 수 있고, 법적 소송까지 이어지는 상당히 민감한 문제가 발생할 수 있기 때문에, 'Entity를 복사하는 한 단계'를 더 거쳐 안전성을 확보하겠다는 것입니다.

*그 외에도 게시판 목록같은 경우 내용에 관련한 데이터는 필요 없기 때문에 불필요한 데이터는 제거하고 성능을 향상시키기 위한 목적도 있습니다. *

주저리 주저리 떠들었습니다만, 간단히 요약하면 아래와 같습니다.

"나는, 제목만 필요하고 내용은 필요없으니까, 커스터마이징할거야!" "그런데, 혹시 오류가 발생할 수도 있으니까, 복사본을 사용하는거야!"

[SpringBoot] 2024 게시판 만들기 실습 ⑥ - CommonResponse & 예외처리

Fri, 22 Nov 2024 06:36:52 GMT

※ 읽기에 앞서

📌 패키지 구조

├── src │ ├── main │ │ ├── java │ │ │ └── com.companyname.projectname │ │ │ ├── common // 패키지 추가 │ │ │ │ ├── controller // 패키지 추가 │ │ │ │ │ └── CommonResponseController.java // 클래스 추가 │ │ │ │ ├── dto // 패키지 추가 │ │ │ │ │ └── CommonResponse.java // 클래스 추가 │ │ │ │ ├── exception // 패키지 추가 │ │ │ │ │ ├── CustomNotFoundException.java // 클래스 추가 │ │ │ │ │ └── CustomValidateException.java // 클래스 추가 │ │ │ │ └── handler // 패키지 추가 │ │ │ │ ├── CustomExceptionHandler.java // 클래스 추가 │ │ │ │ └── GlobalExceptionHandler.java // 클래스 추가 │ │ │ ├── post │ │ │ │ ├── controller │ │ │ │ │ ├── PostControllerV1.java // 클래스 수정 │ │ │ │ │ └── PostControllerV2.java // 클래스 추가 │ │ │ │ ├── dto │ │ │ │ │ ├── PostCreateRequestDto.java │ │ │ │ │ ├── PostUpdateRequestDto.java │ │ │ │ │ ├── PostDetailResponseDto.java │ │ │ │ │ └── PostListResponseDto.java │ │ │ │ ├── model │ │ │ │ │ └── Post.java │ │ │ │ ├── repository │ │ │ │ │ └── PostRepository.java │ │ │ │ └── service │ │ │ │ ├── PostReadService.java │ │ │ │ ├── PostReadServiceImpl.java │ │ │ │ ├── PostWriteService.java │ │ │ │ └── PostWriteServiceImpl.java │ │ │ └── ProjectNameApplication.java │ │ └── resources │ └── test

📌 CommonResponse

CommonResponse는 API 응답 형식을 표준화한 응답 객체입니다.

클라이언트와 서버 간 일관성 제공
가독성과 유지보수성 향상
- 성공 응답 및 에러 응답 구분
- 상태 코드, 메시지, 데이터 포함
  
  이를 통해 각 API에서 통일된 구조의 반환 형식을 사용할 수 있습니다.

이번 글에서는 기존 PostController에 CommonResponse를 적용하여 최적화 및 성능 개선을 해보겠습니다.

PostController 최적화 및 성능 개선

PostController → PostControllerV1 클래스명 변경
PostControllerV2: 최적화 및 개선된 컨트롤러 추가
- URL Mapping 최적화 → RequestMapping 적용
- CommonResponse 적용

📖 CommonResponse

package com.companyname.projectname.common.dto;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CommonResponse {
    private String message;
    private int status;
    private T data;

    // Success Response
    public static CommonResponse success() {
        return CommonResponse.builder()
                .message("The request was successful")
                .status(200)
                .build();
    }

    public static  CommonResponse success(T data) {
        return CommonResponse.builder()
                .message("The request was successful")
                .status(200)
                .data(data)
                .build();
    }

    public static  CommonResponse success(String message, T data) {
        return CommonResponse.builder()
                .message(message)
                .status(200)
                .data(data)
                .build();
    }

    public static  CommonResponse success(int status, String message, T data) {
        return CommonResponse.builder()
                .message(message)
                .status(status)
                .data(data)
                .build();
    }

    // Error Response
    public static CommonResponse error() {
        return CommonResponse.builder()
                .message("Internal Server Error: An unexpected error occurred.")
                .status(500)
                .build();
    }

    public static CommonResponse error(int status) {
        String message = switch (status) {
            case 400 -> "Bad Request: The request is invalid.";
            case 401 -> "Unauthorized: Authentication is required.";
            case 403 -> "Forbidden: Access to the resource is denied.";
            case 404 -> "Not Found: The requested resource could not be found.";
            case 500 -> "Internal Server Error: An unexpected error occurred.";
            default -> "Unexpected Error: An unknown error occurred. Please contact support.";
        };

        return CommonResponse.builder()
                .message(message)
                .status(status)
                .build();
    }

    public static CommonResponse error(int status, String message) {
        return CommonResponse.builder()
                .message(message)
                .status(status)
                .build();
    }

    public static  CommonResponse error(int status, String message, T data) {
        return CommonResponse.builder()
                .message(message)
                .status(status)
                .data(data)
                .build();
    }
}

CommonResponse는 API 응답 형식을 표준화한 응답 객체입니다.

성공 응답 및 에러 응답 구분
상태 코드, 메시지, 데이터 포함

📖 PostControllerV1

package com.companyname.projectname.post.controller;

import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;
import com.companyname.projectname.post.service.PostReadService;
import com.companyname.projectname.post.service.PostWriteService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequiredArgsConstructor
public class PostControllerV1 {
    private final PostReadService postReadService;
    private final PostWriteService postWriteService;

    @GetMapping("/api/v1/post/list")
    public List getOverviewPosts() {
        return postReadService.findAllLists();
    }

    @GetMapping("/api/v1/post/list/detail")
    public List getDetailedPosts() {
        return postReadService.findAllDetails();
    }

    @GetMapping("/api/v1/post/{id}")
    public PostDetailResponseDto getPost(@PathVariable Long id) {
        return postReadService.findById(id);
    }

    @PostMapping("/api/v1/post")
    public PostDetailResponseDto createPost(@RequestBody PostCreateRequestDto requestDto) {
        return postWriteService.create(requestDto);
    }

    @PutMapping("/api/v1/post")
    public PostDetailResponseDto updatePost(@RequestBody PostUpdateRequestDto requestDto) {
        return postWriteService.update(requestDto);
    }

    @DeleteMapping("/api/v1/post/{id}")
    public void deletePost(@PathVariable Long id) {
        postWriteService.delete(id);
    }
}

PostControllerV1 최적화 및 성능 개선

PostController → PostControllerV1 클래스명 변경

📖 PostControllerV2

package com.companyname.projectname.post.controller;

import com.companyname.projectname.common.dto.CommonResponse;
import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;
import com.companyname.projectname.post.service.PostReadService;
import com.companyname.projectname.post.service.PostWriteService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v2/post")
public class PostControllerV2 {
    private final PostReadService postReadService;
    private final PostWriteService postWriteService;

    @GetMapping("/list")
    public ResponseEntity> getOverviewPosts() {
        List responseDto = postReadService.findAllLists();
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success(responseDto));
    }

    @GetMapping("/list/detail")
    public ResponseEntity> getDetailedPosts() {
        List responseDto = postReadService.findAllDetails();
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success(responseDto));
    }

    @GetMapping("/{id}")
    public ResponseEntity> getPost(@PathVariable Long id) {
        PostDetailResponseDto responseDto = postReadService.findById(id);
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success(responseDto));
    }

    @PostMapping
    public ResponseEntity> createPost(@RequestBody PostCreateRequestDto requestDto) {
        PostDetailResponseDto responseDto = postWriteService.create(requestDto);
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success(responseDto));
    }

    @PutMapping
    public ResponseEntity> updatePost(@RequestBody PostUpdateRequestDto requestDto) {
        PostDetailResponseDto responseDto = postWriteService.update(requestDto);
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success(responseDto));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity> deletePost(@PathVariable Long id) {
        postWriteService.delete(id);
        return ResponseEntity.status(HttpStatus.OK).body(CommonResponse.success());
    }
}

PostControllerV2 최적화 및 성능 개선

PostControllerV2: 최적화 및 개선된 컨트롤러
- URL Mapping 최적화 → RequestMapping 적용
- CommonResponse 적용

📖 CRController API 테스트

package com.companyname.projectname.common.controller;

import com.companyname.projectname.common.dto.CommonResponse;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping("/api/v1/common-response")
public class CommonResponseController {
    private static final int NON_STANDARD_SUCCESS_CODE = 700;
    private static final int NON_STANDARD_FAILURE_CODE = 800;
    private static final String NON_STANDARD_SUCCESS_MSG = "Nonstandard success response message.";
    private static final String NON_STANDARD_FAILURE_MSG = "Nonstandard failure response message.";
    private static final Map dummyData = Map.of(
            "key1", "value1",
            "key2", "value2",
            "key3", "value3"
    );

    // Success REST API
    @GetMapping("/success")
    public ResponseEntity> success() {
        return ResponseEntity.status(HttpStatus.OK)
                .body(CommonResponse.success());
    }

    @GetMapping("/success/data")
    public ResponseEntity> successWithData() {
        return ResponseEntity.status(HttpStatus.OK)
                .body(CommonResponse.success(dummyData));
    }

    @GetMapping("/success/message-data")
    public ResponseEntity> successWithMessageAndData() {
        return ResponseEntity.status(HttpStatus.OK)
                .body(CommonResponse.success("Custom Message", dummyData));
    }

    @GetMapping("/success/custom")
    public ResponseEntity> successWithCustom() {
        return ResponseEntity.status(NON_STANDARD_SUCCESS_CODE)
                .body(CommonResponse.success(NON_STANDARD_SUCCESS_CODE, NON_STANDARD_SUCCESS_MSG, dummyData));
    }

    // Error REST API
    @GetMapping("/error")
    public ResponseEntity> error() {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(CommonResponse.error());
    }

    @GetMapping("/error/status/{status}")
    public ResponseEntity> errorWithStatus(@PathVariable Integer status) {
        return ResponseEntity.status(status)
                .body(CommonResponse.error(status));
    }

    @GetMapping("/error/custom")
    public ResponseEntity> errorWithCustom() {
        return ResponseEntity.status(NON_STANDARD_FAILURE_CODE)
                .body(CommonResponse.error(NON_STANDARD_FAILURE_CODE, NON_STANDARD_FAILURE_MSG));
    }

    @GetMapping("/error/detail")
    public ResponseEntity> errorWithDetail() {
        return ResponseEntity.status(NON_STANDARD_FAILURE_CODE)
                .body(CommonResponse.error(NON_STANDARD_FAILURE_CODE, NON_STANDARD_FAILURE_MSG, dummyData));
    }
}

📌 예외처리

Exception

Exception: 컴파일 시 발생하는 검사 예외(Checked Exception) 클래스
- 컴파일 시 예외 처리 요구, 처리하지 않으면 프로그램이 컴파일되지 않음
  - Ex) IOException, SQLException
RuntimeException: 런타임 시 발생하는 비검사 예외(Unchecked Exception) 클래스
- 런타임(실행 중) 시 발생하며, 예외를 처리하지 않으면 프로그램 중단
- 컴파일 시에는 오류 발생하지 않음, 실행 중 예외 발생 전까지는 프로그램 정상 작동
  - Ex) NullPointerException, IllegalArgumentException
CustomException.class: 자주 발생하는 예외를 별도로 정의한 사용자 정의 예외 클래스
- 예외를 표준화하여 프로젝트의 안정성과 유지보수성을 개선
- RuntimeException 예외 클래스 상속
- 재사용성 및 코드 가독성 향상
  - Ex) CustomNotFoundException, CustomValidateException

ExceptionHandler

@RestControllerAdvice를 사용해 프로젝트 전역에서 발생하는 예외 처리
CommonResponse를 활용해 에러 응답 형식을 표준화
보안을 위해 발생한 예외 정보를 응답하는 대신 서버 로그로 남김
반드시 상속 관계를 고려해 구체적인 예외(하위 객체)를 먼저 처리
반드시 상속 관계를 고려해 일반적인 예외(상위 객체)를 나중에 처리

CustomException

자주 발생하는 예외를 별도로 정의한 사용자 정의 예외 클래스
- 예외를 표준화하여 프로젝트의 안정성과 유지보수성을 개선
- RuntimeException 예외 클래스 상속
- 재사용성 및 코드 가독성 향상
  - Ex) CustomNotFoundException, CustomValidateException
    
    CustomExceptionHandler
전역적으로 예외를 처리하며, 사용자 정의 오류에 대한 표준화된 응답 제공
사용자 정의 예외를 서버 로그에 남겨 디버깅 및 유지보수 효율성 향상
보안을 위해 상태 코드와 추상적인 예외 메시지를 클라이언트에 전달

GlobalException

프로젝트 전반에서 발생하는 예상치 못한 예외를 포괄적으로 처리하는 상위 예외 클래스
Exception: 컴파일 시 발생하는 검사 예외(Checked Exception) 클래스
- 컴파일 시 예외 처리 요구, 처리하지 않으면 프로그램이 컴파일되지 않음
  - Ex) IOException, SQLException
RuntimeException: 런타임 시 발생하는 비검사 예외(Unchecked Exception) 클래스
- 런타임(실행 중) 시 발생하며, 예외를 처리하지 않으면 프로그램 중단
- 컴파일 시에는 오류 발생하지 않음, 실행 중 예외 발생 전까지는 프로그램 정상 작동
  - Ex) NullPointerException, IllegalArgumentException
    
    GlobalExceptionHandler
전역적으로 예외를 처리하며, 예기치 못한 오류에 대한 표준화된 응답 제공
모든 예외를 서버 로그에 남겨 디버깅 및 유지보수 효율성 향상
보안을 위해 상태 코드와 추상적인 예외 메시지를 클라이언트에 전달

CustomException 및 ExceptionHandler 구현

CustomException 구현
- CustomNotFoundException 구현
- CustomValidateException 구현
CustomExceptionHandler 구현
GlobalExceptionHandler 구현

📖 CustomNotFoundException

package com.companyname.projectname.common.exception;

public class CustomNotFoundException extends RuntimeException {

    public CustomNotFoundException() {
        super("The requested resource could not be found.");
    }

    public CustomNotFoundException(String message) {
        super(message);
    }

    public CustomNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}

CustomException

자주 발생하는 예외를 별도로 정의한 사용자 정의 예외 클래스
- 예외를 표준화하여 프로젝트의 안정성과 유지보수성을 개선
- RuntimeException 예외 클래스 상속
- 재사용성 및 코드 가독성 향상

📖 CustomValidateException

package com.companyname.projectname.common.exception;

public class CustomValidateException extends RuntimeException {

    public CustomValidateException() {
        super("The request is invalid, validation failed.");
    }

    public CustomValidateException(String message) {
        super(message);
    }

    public CustomValidateException(String message, Throwable cause) {
        super(message, cause);
    }
}

CustomException

자주 발생하는 예외를 별도로 정의한 사용자 정의 예외 클래스
- 예외를 표준화하여 프로젝트의 안정성과 유지보수성을 개선
- RuntimeException 예외 클래스 상속
- 재사용성 및 코드 가독성 향상

📖 CustomExceptionHandler

CustomExceptionHandler

전역적으로 예외를 처리하며, 사용자 정의 오류에 대한 표준화된 응답 제공
사용자 정의 예외를 서버 로그에 남겨 디버깅 및 유지보수 효율성 향상
보안을 위해 상태 코드와 추상적인 예외 메시지를 클라이언트에 전달

package com.companyname.projectname.common.handler;

import com.companyname.projectname.common.dto.CommonResponse;
import com.companyname.projectname.common.exception.CustomNotFoundException;
import com.companyname.projectname.common.exception.CustomValidateException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(CustomNotFoundException.class)
    public ResponseEntity> handleCustomNotFoundException(CustomNotFoundException e) {
        log.error("CustomExceptionHandler CustomNotFoundException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(801)
                .body(CommonResponse.error(801));
    }

    @ExceptionHandler(CustomValidateException.class)
    public ResponseEntity> handleCustomValidateException(CustomValidateException e) {
        log.error("CustomExceptionHandler CustomValidateException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(802)
                .body(CommonResponse.error(802));
    }
}

ExceptionHandler

@RestControllerAdvice를 사용해 프로젝트 전역에서 발생하는 예외 처리
CommonResponse를 활용해 에러 응답 형식을 표준화
보안을 위해 발생한 예외 정보를 응답하는 대신 서버 로그로 남김
반드시 상속 관계를 고려해 구체적인 예외(하위 객체)를 먼저 처리
반드시 상속 관계를 고려해 일반적인 예외(상위 객체)를 나중에 처리

📖 GlobalExceptionHandler

GlobalExceptionHandler

전역적으로 예외를 처리하며, 예기치 못한 오류에 대한 표준화된 응답 제공
모든 예외를 서버 로그에 남겨 디버깅 및 유지보수 효율성 향상
보안을 위해 상태 코드와 추상적인 예외 메시지를 클라이언트에 전달

package com.companyname.projectname.common.handler;

import com.companyname.projectname.common.dto.CommonResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.sql.SQLException;

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity> handleIllegalArgumentException(IllegalArgumentException e) {
        log.error("GlobalExceptionHandler IllegalArgumentException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                .body(CommonResponse.error(400));
    }

    @ExceptionHandler(NullPointerException.class)
    public ResponseEntity> handleNullPointerException(NullPointerException e) {
        log.error("GlobalExceptionHandler NullPointerException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(CommonResponse.error(500));
    }

    @ExceptionHandler(SQLException.class)
    public ResponseEntity> handleSQLException(SQLException e) {
        log.error("GlobalExceptionHandler SQLException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(CommonResponse.error(500));
    }

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity> handleRuntimeException(RuntimeException e) {
        log.error("GlobalExceptionHandler RuntimeException occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(CommonResponse.error(500));
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity> handleGeneralException(Exception e) {
        log.error("GlobalExceptionHandler General Exception occurred: {}", e.getMessage(), e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(CommonResponse.error(500));
    }
}

ExceptionHandler

@RestControllerAdvice를 사용해 프로젝트 전역에서 발생하는 예외 처리
CommonResponse를 활용해 에러 응답 형식을 표준화
보안을 위해 발생한 예외 정보를 응답하는 대신 서버 로그로 남김
반드시 상속 관계를 고려해 구체적인 예외(하위 객체)를 먼저 처리
반드시 상속 관계를 고려해 일반적인 예외(상위 객체)를 나중에 처리

📖 PostReadServiceImpl

package com.companyname.projectname.post.service;

import com.companyname.projectname.common.exception.CustomNotFoundException;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;
import com.companyname.projectname.post.model.Post;
import com.companyname.projectname.post.repository.PostRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostReadServiceImpl implements PostReadService {

    private final PostRepository postRepository;

    @Override
    public PostDetailResponseDto findById(Long id) {
        Post entity = postRepository.findById(id).orElseThrow(
                () -> new CustomNotFoundException("Post not found with id: " + id));
        return new PostDetailResponseDto(entity);
    }

    // ... 이하 변경 없음 ...
}

유효성 검사 로직 추가

예제 코드를 참고하여 필요에 따라 응용하세요.

throw new CustomNotFoundException();
throw new CustomValidateException();

📖 PostWriteServiceImpl

package com.companyname.projectname.post.service;

import com.companyname.projectname.common.exception.CustomNotFoundException;
import com.companyname.projectname.common.exception.CustomValidateException;
import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;
import com.companyname.projectname.post.model.Post;
import com.companyname.projectname.post.repository.PostRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
@RequiredArgsConstructor
public class PostWriteServiceImpl implements PostWriteService {

    private final PostRepository postRepository;

    @Override
    public PostDetailResponseDto create(PostCreateRequestDto requestDto) {
        if (requestDto.getTitle() == null || requestDto.getTitle().isEmpty())
            throw new CustomValidateException("Post title must not be empty.");
        if (requestDto.getContent() == null || requestDto.getContent().isEmpty())
            throw new CustomValidateException("Post content must not be empty.");

        return new PostDetailResponseDto(postRepository.save(requestDto.toEntity()));
    }

    @Override
    public PostDetailResponseDto update(PostUpdateRequestDto requestDto) {
        Post entity = postRepository.findById(requestDto.getId()).orElseThrow(
                () -> new CustomNotFoundException("Post not found with id: " + requestDto.getId()));
        return new PostDetailResponseDto(postRepository.save(entity.update(requestDto)));
    }

    @Override
    public void delete(Long id) {
        if (!postRepository.existsById(id))
            throw new CustomNotFoundException("Cannot delete Post. Post not found with id: " + id);
        postRepository.deleteById(id);
    }
}

유효성 검사 로직 추가

예제 코드를 참고하여 필요에 따라 응용하세요.

throw new CustomNotFoundException();
throw new CustomValidateException();

[SpringBoot] 2024 게시판 만들기 실습 ⑤ - Controller

Thu, 21 Nov 2024 09:48:22 GMT

※ 읽기에 앞서

📌 패키지 구조

├── src │ ├── main │ │ ├── java │ │ │ └── com.companyname.projectname │ │ │ ├── post │ │ │ │ ├── controller // 패키지 추가 │ │ │ │ │ └── PostController.java // 클래스 추가 │ │ │ │ ├── dto │ │ │ │ │ ├── PostCreateRequestDto.java │ │ │ │ │ ├── PostUpdateRequestDto.java │ │ │ │ │ ├── PostDetailResponseDto.java │ │ │ │ │ └── PostListResponseDto.java │ │ │ │ ├── model │ │ │ │ │ └── Post.java │ │ │ │ ├── repository │ │ │ │ │ └── PostRepository.java │ │ │ │ └── service │ │ │ │ ├── PostReadService.java │ │ │ │ ├── PostReadServiceImpl.java │ │ │ │ ├── PostWriteService.java │ │ │ │ └── PostWriteServiceImpl.java │ │ │ └── ProjectNameApplication.java │ │ └── resources │ └── test

📌 Controller

package com.companyname.projectname.post.controller;

import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;
import com.companyname.projectname.post.service.PostReadService;
import com.companyname.projectname.post.service.PostWriteService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequiredArgsConstructor
public class PostController {
    private final PostReadService postReadService;
    private final PostWriteService postWriteService;

    @GetMapping("/api/v1/post/list")
    public List getOverviewPosts() {
        return postReadService.findAllLists();
    }

    @GetMapping("/api/v1/post/list/detail")
    public List getDetailedPosts() {
        return postReadService.findAllDetails();
    }

    @GetMapping("/api/v1/post/{id}")
    public PostDetailResponseDto getPost(@PathVariable Long id) {
        return postReadService.findById(id);
    }

    @PostMapping("/api/v1/post")
    public PostDetailResponseDto createPost(@RequestBody PostCreateRequestDto requestDto) {
        return postWriteService.create(requestDto);
    }

    @PutMapping("/api/v1/post")
    public PostDetailResponseDto updatePost(@RequestBody PostUpdateRequestDto requestDto) {
        return postWriteService.update(requestDto);
    }

    @DeleteMapping("/api/v1/post/{id}")
    public void deletePost(@PathVariable Long id) {
        postWriteService.delete(id);
    }
}

@RestController
- API 서버를 구현할 때 주로 사용하며, 컨트롤러 클래스를 RESTful 웹 서비스의 엔드포인트로 만들어줌
- @Controller와 @ResponseBody를 결합한 형태로, 반환값을 JSON 또는 XML 형태로 바로 변환하여 클라이언트에 전달
@RequiredArgsConstructor
- 필드 주입 대신 생성자 주입으로 PostService 자동으로 의존성 주입
- Spring DI(Dependency Injection) 컨테이너에서 안전하게 의존성 관리
- 선언된 final 필드는 생성자에서 자동으로 초기화

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping
- HTTP 메서드별 요청을 처리하는 매핑 어노테이션
  - @GetMapping: GET 요청 처리, 주로 조회 작업에 사용
  - @PostMapping: POST 요청 처리, 주로 생성 작업에 사용
  - @PutMapping: PUT 요청 처리, 주로 업데이트 작업에 사용
  - @DeleteMapping: DELETE 요청 처리, 주로 삭제 작업에 사용
- RESTful API를 구현할 때 간결하고 가독성 높은 코드 작성 가능

@PathVariable
- URL 경로에 포함된 변수를 매핑하는 데 사용
- 주로 RESTful API에서 자원 식별자(ID) 등을 처리할 때 사용
@RequestBody
- HTTP 요청의 본문(Body)을 Java 객체로 변환하여 매핑하는 데 사용
- 주로 POST, PUT 요청에서 JSON 데이터를 객체로 변환할 때 사용

[SpringBoot] 2024 게시판 만들기 실습 ④ - Service, Repository

Thu, 21 Nov 2024 09:46:28 GMT

※ 읽기에 앞서

📌 패키지 구조

├── src │ ├── main │ │ ├── java │ │ │ └── com.companyname.projectname │ │ │ ├── post │ │ │ │ ├── dto │ │ │ │ │ ├── PostCreateRequestDto.java │ │ │ │ │ ├── PostUpdateRequestDto.java │ │ │ │ │ ├── PostDetailResponseDto.java │ │ │ │ │ └── PostListResponseDto.java │ │ │ │ ├── model │ │ │ │ │ └── Post.java │ │ │ │ ├── repository // 패키지 추가 │ │ │ │ │ └── PostRepository.java // 인터페이스 추가 │ │ │ │ └── service // 패키지 추가 │ │ │ │ ├── PostReadService.java // 인터페이스 추가 │ │ │ │ ├── PostReadServiceImpl.java // 클래스 추가 │ │ │ │ ├── PostWriteService.java // 인터페이스 추가 │ │ │ │ └── PostWriteServiceImpl.java // 클래스 추가 │ │ │ └── ProjectNameApplication.java │ │ └── resources │ └── test

📌 Repository

package com.companyname.projectname.post.repository;

import com.companyname.projectname.post.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    // 1. 이름 기반 메서드 (쿼리 메서드)

    // 기본 메서드
    List findByTitle(String title);
    List findByContent(String content);
    List findByTitleContaining(String title);
    List findByContentContaining(String content);
    List findByTitleContainingIgnoreCase(String title);
    List findByContentContainingIgnoreCase(String content);

    // 복합 메서드
    List findByTitleAndContent(String title, String content);
    List findByTitleContainingOrContentContaining(String title, String content);
    List findByTitleContainingAndContentContaining(String title, String content);
    List findByTitleContainingIgnoreCaseOrContentContainingIgnoreCase(String title, String content);
    List findByTitleContainingIgnoreCaseAndContentContainingIgnoreCase(String title, String content);

    // 날짜 기반 메서드 (생성 일자 기준)
    List findByCreatedDateAfter(LocalDateTime date);
    List findByCreatedDateBefore(LocalDateTime date);
    List findByCreatedDateBetween(LocalDateTime sDate, LocalDateTime eDate);

    // 날짜 기반 메서드 (수정 일자 기준)
    List findByUpdatedDateAfter(LocalDateTime date);
    List findByUpdatedDateBefore(LocalDateTime date);
    List findByUpdatedDateBetween(LocalDateTime sDate, LocalDateTime eDate);
}

JPA는 Entity 클래스의 필드명을 기준으로, 메서드명을 통해 JPA 원시 쿼리를 자동으로 생성
필요에 따라 메서드를 추가하되, 반드시 메서드명, 매개변수명에 주의할 것

📌 Service

확장성과 유지보수성을 고려하여 Interface로 구현하였으며, @Transactional 조회 성능 최적화를 위해 읽기, 쓰기 작업을 분리

📖 PostReadService

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;

import java.time.LocalDateTime;
import java.util.List;

public interface PostReadService {
    PostDetailResponseDto findById(Long id);
    List findAllLists();
    List findAllDetails();

    // 예시, 필요한 경우 작성
    List findByTitle(String title);
    List findByContent(String content);
    List findByTitleContaining(String title);
    List findByContentContaining(String content);
    List findByTitleContainingIgnoreCase(String title);
    List findByContentContainingIgnoreCase(String content);

    List findByTitleAndContent(String title, String content);
    List findByTitleContainingOrContentContaining(String title, String content);
    List findByTitleContainingAndContentContaining(String title, String content);
    List findByTitleContainingIgnoreCaseOrContentContainingIgnoreCase(String title, String content);
    List findByTitleContainingIgnoreCaseAndContentContainingIgnoreCase(String title, String content);

    List findByCreatedDateAfter(LocalDateTime date);
    List findByCreatedDateBefore(LocalDateTime date);
    List findByCreatedDateBetween(LocalDateTime sDate, LocalDateTime eDate);

    List findByUpdatedDateAfter(LocalDateTime date);
    List findByUpdatedDateBefore(LocalDateTime date);
    List findByUpdatedDateBetween(LocalDateTime sDate, LocalDateTime eDate);
}

Interface
- 클래스 간 공통된 메서드의 규격을 정의
- 다형성을 활용하여 유연하고 확장 가능한 코드 설계 가능
- 메서드 선언부만 존재하며, 구현부는 구현 클래스에서 정의
- 다중 상속을 지원하여 다양한 인터페이스를 한 클래스에서 구현 가능

Interface 주의할 점
- 구현 클래스에서 반드시 메서드를 @Override해야 함
- 다중 상속 시 중복된 메서드가 존재하는 경우 충돌에 주의
- 구현해야할 기능의 정의는 결정되었으나, 로직은 결정되지 않은 경우 사용
- 필요 이상으로 많은 메서드를 정의하면 구현 클래스의 복잡도를 증가시킬 수 있음

📖 PostReadServiceImpl

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostListResponseDto;
import com.companyname.projectname.post.model.Post;
import com.companyname.projectname.post.repository.PostRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostReadServiceImpl implements PostReadService {

    private final PostRepository postRepository;

    @Override
    public PostDetailResponseDto findById(Long id) {
        Post entity = postRepository.findById(id).orElseThrow(
                () -> new IllegalArgumentException("Post not found with id: " + id));
        return new PostDetailResponseDto(entity);
    }

    @Override
    public List findAllLists() {
        return postRepository.findAll().stream().map(PostListResponseDto::new).toList();
    }

    @Override
    public List findAllDetails() {
        return postRepository.findAll().stream().map(PostDetailResponseDto::new).toList();
    }

    @Override
    public List findByTitle(String title) {
        return postRepository.findByTitle(title).stream().map(PostListResponseDto::new).toList();
    }

    @Override
    public List findByContent(String content) {
        return postRepository.findByContent(content).stream().map(PostListResponseDto::new).toList();
    }

    // ... 중략 ...
}

@Transactional(readOnly = true)

Spring 제공 어노테이션, 조회 전용 메서드에 설정하여 성능 최적화를 도모 쓰기 작업을 막고 읽기 전용으로 동작, 일부 데이터베이스에서 캐시를 활용하도록 도움
트랜잭션 범위를 설정하고, 데이터베이스 작업의 일관성과 원자성을 보장
데이터 수정/삭제/저장 작업에서 예외 발생 시, 롤백을 자동으로 처리
- 클래스 레벨에 선언하면 해당 클래스의 모든 메서드에 트랜잭션 속성 적용
- 메서드 레벨에 선언하면 해당 메서드에만 트랜잭션 속성 적용
- 클래스 레벨과 메서드 레벨에 모두 선언하면 메서드 레벨 설정이 클래스 레벨 설정을 재정의

@RequiredArgsConstructor
- 필드 주입 대신 생성자 주입으로 PostRepository 자동으로 의존성 주입
- Spring DI(Dependency Injection) 컨테이너에서 안전하게 의존성 관리
- 선언된 final 필드는 생성자에서 자동으로 초기화
IllegalArgumentException
- 데이터가 없을 경우, orElseThrow()를 사용하여 명시적으로 예외를 던짐
- 추후 별도의 예외 클래스를 생성하여 더 구체적인 예외 처리가 가능하도록 변경

📖 PostWriteService

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;

public interface PostWriteService {
    PostDetailResponseDto create(PostCreateRequestDto requestDto);
    PostDetailResponseDto update(PostUpdateRequestDto requestDto);
    void delete(Long id);
}

Interface
- 클래스 간 공통된 메서드의 규격을 정의
- 다형성을 활용하여 유연하고 확장 가능한 코드 설계 가능
- 메서드 선언부만 존재하며, 구현부는 구현 클래스에서 정의
- 다중 상속을 지원하여 다양한 인터페이스를 한 클래스에서 구현 가능

Interface 주의할 점
- 구현 클래스에서 반드시 메서드를 @Override해야 함
- 다중 상속 시 중복된 메서드가 존재하는 경우 충돌에 주의
- 구현해야할 기능의 정의는 결정되었으나, 로직은 결정되지 않은 경우 사용
- 필요 이상으로 많은 메서드를 정의하면 구현 클래스의 복잡도를 증가시킬 수 있음

📖 PostWriteServiceImpl

package com.companyname.projectname.post.service;

import com.companyname.projectname.post.dto.PostCreateRequestDto;
import com.companyname.projectname.post.dto.PostDetailResponseDto;
import com.companyname.projectname.post.dto.PostUpdateRequestDto;
import com.companyname.projectname.post.model.Post;
import com.companyname.projectname.post.repository.PostRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
@RequiredArgsConstructor
public class PostWriteServiceImpl implements PostWriteService {

    private final PostRepository postRepository;

    @Override
    public PostDetailResponseDto create(PostCreateRequestDto requestDto) {
        return new PostDetailResponseDto(postRepository.save(requestDto.toEntity()));
    }

    @Override
    public PostDetailResponseDto update(PostUpdateRequestDto requestDto) {
        Post entity = postRepository.findById(requestDto.getId()).orElseThrow(
                () -> new IllegalArgumentException("Post not found with id: " + requestDto.getId()));
        return new PostDetailResponseDto(postRepository.save(entity.update(requestDto)));
    }

    @Override
    public void delete(Long id) {
        postRepository.deleteById(id);
    }
}

@Transactional

Spring 제공 어노테이션
트랜잭션 범위를 설정하고, 데이터베이스 작업의 일관성과 원자성을 보장
데이터 수정/삭제/저장 작업에서 예외 발생 시, 롤백을 자동으로 처리
- 클래스 레벨에 선언하면 해당 클래스의 모든 메서드에 트랜잭션 속성 적용
- 메서드 레벨에 선언하면 해당 메서드에만 트랜잭션 속성 적용
- 클래스 레벨과 메서드 레벨에 모두 선언하면 메서드 레벨 설정이 클래스 레벨 설정을 재정의

@RequiredArgsConstructor
- 필드 주입 대신 생성자 주입으로 PostRepository 자동으로 의존성 주입
- Spring DI(Dependency Injection) 컨테이너에서 안전하게 의존성 관리
- 선언된 final 필드는 생성자에서 자동으로 초기화
IllegalArgumentException
- 데이터가 없을 경우, orElseThrow()를 사용하여 명시적으로 예외를 던짐
- 추후 별도의 예외 클래스를 생성하여 더 구체적인 예외 처리가 가능하도록 변경

[SpringBoot] 2024 게시판 만들기 실습 ② - MySQL 연동

Thu, 21 Nov 2024 08:32:32 GMT

※ 읽기에 앞서

📌 build.grade

build.grade 의존성 라이브러리 추가

dependencies {
    ...
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'    // 추가
    runtimeOnly 'com.mysql:mysql-connector-j'                                // 추가
    ...
}

📌 application.properties

📖 application.properties

# MySQL Settings
spring.datasource.url=jdbc:mysql://localhost:3306/myschema?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Seoul
spring.datasource.username=[MySQL계정이름]
spring.datasource.password=[MySQL비밀번호]
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA Settings
spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql: true

spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
- 자동 감지가 실패하거나, 올바르지 않은 Dialect가 선택될 때 명시적으로 설정
- 특정 데이터베이스 버전을 위한 Dialect를 지정하고 싶을 때 명시적으로 설정
  - MySQL 5.x: org.hibernate.dialect.MySQLDialect
  - MySQL 8.x: org.hibernate.dialect.MySQL8Dialect
spring.jpa.properties.hibernate.format_sql=true
- Hibernate가 실행하는 SQL 쿼리를 읽기 쉬운 포맷으로 출력
spring.jpa.hibernate.ddl-auto=update: Spring Boot Application에서
- Hibernate의 DDL(Data Definition Language) 생성 및 동작 방식을 제어하는 설정
- 데이터베이스 스키마(테이블, 속성 등)의 상태를, Entity 클래스와 동기화
  - none: 데이터베이스 스키마 변경 작업을 수행하지 않음. 수동 관리 필요.
  - validate: 데이터베이스 스키마와 Entity 불일치 시 애플리케이션 실행 오류
  - update: Entity에 맞춰 데이터베이스 스키마 업데이트 (운영 환경 비추천)
  - create: 애플리케이션 실행 시 스키마 삭제 후 새로 생성 (기존 데이터 삭제)
  - create-drop: 애플리케이션 실행 시 스키마 생성, 종료 시 삭제 (테스트 환경에 적합)
spring.jpa.show-sql=true
- Hibernate가 실행하는 SQL 쿼리를 콘솔(로그)에 출력하는 설정
- 애플리케이션에서 JPA를 통해 데이터베이스와 상호작용할 때, 생성되고 실행되는 SQL 원시 쿼리를 콘솔(로그)에 표시

📖 MySQL JDBC 설정 옵션

application.properties

spring.datasource.url=jdbc:mysql://[IP]:[포트번호]/[DB스키마]?
useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Seoul

useUnicode=true
- 데이터베이스가 유니코드(UTF-8)로 데이터를 읽고 쓰도록 설정
- 한글 데이터를 올바르게 처리하기 위해 필수
characterEncoding=utf8
- 데이터베이스와의 통신에 사용할 문자 인코딩을 UTF-8로 설정
- 한글 데이터를 올바르게 처리하기 위해 필수
serverTimezone=Asia/Seoul
- 서버의 시간대를 대한민국 표준시간(Asia/Seoul)으로 설정
- 시간 관련 연산에서 정확한 데이터를 보장합니다.
allowPublicKeyRetrieval=true
- MySQL 8.x 버전 이상에서 Public Key Retrieval 문제 방지를 위해 사용
- MySQL 8.x 버전 이상에서 보안 정책에 따른 옵션으로, 로컬 개발 환경에서 사용
useSSL=false
- SSL 비활성화 (로컬/테스트 환경에서 사용)
- 로컬 또는 테스트 환경에서는 SSL 설정이 필요하지 않은 경우가 많아 보통 비활성화

📌 MySQL

📖 MySQL Connection Instance 생성

Connection Name: ProjectName
Store in Vault ... - root - 1234 - OK
- User: root
- Password: 1234

Test Connection - OK - OK

📖 MySQL Schema 생성

ProjectName Instance 연결 (클릭)
Create a new schema in the connected server
Name: myschema - Apply - Apply - Finish

📖 MySQL Connection Instance Schema 설정

ProjectName Instance - 마우스 우클릭 - Edit Connection
Default Schema: myschema
Test Connection - OK

📖 MySQL 연동 결과 확인

데이터베이스에 다시 접속했을 때, myschema 가 굵은 글씨로 표시되어야 합니다.

[SpringBoot] 2024 게시판 만들기 실습 ① - 프로젝트 생성

Thu, 21 Nov 2024 06:57:41 GMT

※ 읽기에 앞서

📌 Spring Initializr

아래의 공식 사이트에 접속한 후, 아래와 같이 내용을 입력해주세요.

[Spring Initializr] https://start.spring.io/

📖 입력 내용

Project : Gradle - Groovy
Language : Java
Spring Boot : 3.3.5, 버전 뒤에 아무 것도 붙지 않은 것 중, 가장 최신 버전 선택
Project Metadata :
- Group : com.companyname
- Artifact : ProjectName
- Name : ProjectName
- Description : FreeBoard Project for Spring Boot
- Package name : com.companyname.projectname
- Packaging : Jar
- Java : 17
Dependencies ADD DEPENDENCIES
- Lombok
- Spring Web
- Spring Boot Dev Tools
GENERATE
다운로드된 파일 압축 해제 후, 인텔리제이에서 프로젝트 열기

📖 입력 내용 설명

Project : 빌드 도구 선택
- Gradle - Groovy : Groovy DSL을 사용하는 Gradle 빌드 도구 build.gradle
- Gradle - Kotlin : Kotlin DSL을 사용하는 Gradle 빌드 도구 build.gradle.kts
- Maven : XML 기반의 정형화된 빌드 도구 pom.xml
Language : 프로그래밍 언어 선택
Spring Boot : 버전 뒤에 아무 것도 붙지 않은 것 중, 가장 최신 버전 선택
- SNAPSHOT : 아직 개발이 완료되지 않은 버전
- M(Milestone) : 개발은 완료되었으나, 아직 기능 개선 또는 버그 수정중인 버전
- RC(Release Candidate) : 기능 개선과 버그 수정이 완료되었으나, 최종적으로 릴리즈되지는 않은 버전
Project Metadata : 프로젝트 정보 입력
- Group : 기업명 혹은 개발자명, 보통 기업 도메인 명을 역순으로 입력
  - ex) naver.com -> com.naver
  - ex) hong-gildong.com -> com.hong-gildong
- Artifact : 빌드 결과물 이름 (수동 입력)
- Name : 프로젝트명 (Artifact를 수정하면 자동으로 수정됨)
- Description : 프로젝트에 대한 간략한 설명 (필요시 입력)
- Package name : 프로젝트에 생성할 패키지 설정 (일부 수정)
  - 패키지명은 모두 소문자를 사용하는 것을 권장함
  - ex) com.companyname.ProjectName -> com.companyname.projectname
- Packaging : 배포를 위한 프로젝트 압축 방법 선택
- Java : 개발환경 및 배포환경 JDK 버전 선택
  - 본 게시글 작성일(2024.11.22) 기준 최신 LTS 버전: JDK 21
  - 정석적으로는, Java 지원 기간이 긴 최신 LTS 버전 선택 권장
  - 현실적으로는, 구버전 호환성을 고려해 구 JDK LTS 버전 선택
  - Spring Boot 3.x 부터는 Java 17 이상 지원 -> JDK 17 권장
    - Spring Boot 2.x 지원 종료 -> Java 8 지원 종료
Dependencies : 프로젝트에 필요한 의존성 라이브러리 선택
- Lombok: 어노테이션 기반 반복적인 코드(보일러플레이트 코드) 생성 도구 제공
- Spring Web: RESTful Web Application & MVC 기반 웹 서비스 개발 기본 기능 지원
- Spring Boot Dev Tools: 자동 재시작 및 캐싱 비활성화 등 개발 편의성 기능 제공

[SpringBoot] 2024 게시판 만들기 실습 ③ - Entity, DTO

Thu, 21 Nov 2024 06:11:58 GMT

※ 읽기에 앞서

본 예제에서는 Lombok과 JPA를 사용한 실습을 설명하고 있으므로, 만약 설치되어있지 않다면 미리 세팅하고 오셔야 오류없이 실행됩니다.

📌 패키지 구조

├── src │ ├── main │ │ ├── java │ │ │ └── com.companyname.projectname │ │ │ ├── post // 패키지 추가 │ │ │ │ ├── dto // 패키지 추가 │ │ │ │ │ ├── PostCreateRequestDto.java // 클래스 추가 │ │ │ │ │ ├── PostUpdateRequestDto.java // 클래스 추가 │ │ │ │ │ ├── PostDetailResponseDto.java // 클래스 추가 │ │ │ │ │ └── PostListResponseDto.java // 클래스 추가 │ │ │ │ └── model // 패키지 추가 │ │ │ │ └── Post.java // 클래스 추가 │ │ │ └── ProjectNameApplication.java │ │ └── resources │ └── test

📌 Entity

사실 Entity는 특별히 대단할 것이 없습니다.

Entity는 테이블 정의이자 데이터의 단위인데 'Java에서는 이것을 Class라고 합니다.'

Java를 좀 공부해보셨던 분들이라면, 이 말을 듣고 아마 이런 생각을 하셨을겁니다.

"아, '데이터의 정의`는 'Class' 였지!"

📖 Post.java

package com.companyname.projectname.post.model;

import com.companyname.projectname.post.dto.PostRequestDto;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import java.time.LocalDateTime;

@Entity
@Getter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;

    @CreationTimestamp
    private LocalDateTime createdDate;
    @UpdateTimestamp
    private LocalDateTime updatedDate;

    // Method, for updating data
    public Post update(PostRequestDto requestDto) {
        this.title = requestDto.getTitle();
        this.content = requestDto.getContent();
        return this;
    }
}

@Entity: 이 클래스가 JPA 엔티티임을 명시
@Getter: 클래스의 모든 필드에 대해 Getter 메서드를 자동 생성
@Builder: 빌더 패턴을 통해 객체 생성 지원
@NoArgsConstructor: 매개변수가 없는 기본 생성자 자동 생성
@AllArgsConstructor: 모든 필드를 매개변수로 갖는 생성자 자동 생성 변수명을 기준으로 매개변수를 필드에 자동으로 초기화

@Id: 해당 필드가 엔티티의 기본 키(Primary Key)임을 지정
@GeneratedValue: 데이터베이스에서 기본 키가 자동으로 생성되도록 설정
- (strategy = GenerationType.IDENTITY): 데이터베이스의 AUTO_INCREMENT 기능을 사용하여 기본 키를 생성
@CreationTimestamp: 엔티티가 생성될 때 자동으로 현재 시간을 설정
@UpdateTimestamp: 엔티티가 업데이트될 때 자동으로 현재 시간을 설정

각각의 @Annotation은 이를 사용하거나, 사용하지 말아야 할 이유가 존재합니다.

@Builder는 추후 RequestDto -> Entity 클래스로 변환하는데 사용한다.
데이터베이스와 직접 연결되는 엔티티는, @Setter 사용을 지양한다.
수정이 필요한 경우 필요한 데이터에 대해서 메서드로 처리한다.
update() 메서드는 매개변수가 RequestDto임에 주의한다.
- 아직 구현되지 않았다면 RequestDto부터 구현한다.

@Annotation에 대한 더 자세한 정보는 구글링을 통해 알아보시기 바랍니다. 검색 키워드는 Lombok Annotation, JPA Annotation입니다.

📌 RequestDTO

각각의 @Annotation은 이를 사용하거나, 사용하지 말아야 할 이유가 존재합니다.

@Data: 간단한 데이터 클래스 작성을 위한 종합적인 기능 제공
- @Getter, @Setter, @ToString 포함
- @EqualsAndHashCode, @RequiredArgsConstructor 포함
@Builder: 빌더 패턴을 통해 객체 생성 지원
@NoArgsConstructor: 매개변수가 없는 기본 생성자 자동 생성
@AllArgsConstructor: 모든 필드를 매개변수로 갖는 생성자 자동 생성 변수명을 기준으로 매개변수를 필드에 자동으로 초기화
DTO는 비교적 데이터 수정에 관대하므로, @Data를 사용해 중복 코드를 감소
toEntity() 메서드는 Post.java 엔티티의 @Builder 패턴을 사용해, RequestDto -> Entity 클래스로 변환한다.

📖 PostCreateRequestDto.java

package com.companyname.projectname.post.dto;

import com.companyname.projectname.post.model.Post;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PostCreateRequestDto {
    private String title;
    private String content;

    public Post toEntity() {
        return Post.builder()
                .title(this.title)
                .content(this.content)
                .build();
    }
}

데이터베이스에 아직 데이터가 없는 상태이므로 Long id를 기입하지 않습니다.

📖 PostUpdateRequestDto.java

package com.companyname.projectname.post.dto;

import com.companyname.projectname.post.model.Post;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PostUpdateRequestDto {
    private Long id;
    private String title;
    private String content;

    public Post toEntity() {
        return Post.builder()
                .id(this.id)
                .title(this.title)
                .content(this.content)
                .build();
    }
}

데이터베이스에 존재하는 데이터를 수정하는 것이므로, Long id를 기입합니다.

📌 ResponseDTO

각각의 @Annotation은 이를 사용하거나, 사용하지 말아야 할 이유가 존재합니다.

@Data: 간단한 데이터 클래스 작성을 위한 종합적인 기능 제공
- @Getter, @Setter, @ToString 포함
- @EqualsAndHashCode, @RequiredArgsConstructor 포함
@Builder: 빌더 패턴을 통해 객체 생성 지원
@NoArgsConstructor: 매개변수가 없는 기본 생성자 자동 생성
@AllArgsConstructor: 모든 필드를 매개변수로 갖는 생성자 자동 생성 변수명을 기준으로 매개변수를 필드에 자동으로 초기화
DTO는 비교적 데이터 수정에 관대하므로, @Data를 사용해 중복 코드를 감소
생성자는, 데이터베이스로부터 읽은 Entity 데이터를 DTO로 변환하는데 사용 Entity -> RequestDto 클래스로 변환한다.

📖 PostListResponseDto.java

package com.companyname.projectname.post.dto;

import com.companyname.projectname.post.model.Post;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PostListResponseDto {
    private Long id;
    private String title;
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;

    // Custom Constructor, convert data from entity to dto
    public PostListResponseDto(Post entity) {
        this.id = entity.getId();
        this.title = entity.getTitle();
        this.createdDate = entity.getCreatedDate();
        this.updatedDate = entity.getUpdatedDate();
    }
}

게시글의 목록을 조회할 때, content(내용)은 불필요하므로 필드에 기입하지 않습니다.

📖 PostDetailResponseDto.java

package com.companyname.projectname.post.dto;

import com.companyname.projectname.post.model.Post;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PostDetailResponseDto {
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;

    // Custom Constructor, convert data from entity to dto
    public PostDetailResponseDto(Post entity) {
        this.id = entity.getId();
        this.title = entity.getTitle();
        this.content = entity.getContent();
        this.createdDate = entity.getCreatedDate();
        this.updatedDate = entity.getUpdatedDate();
    }
}

게시글을 상세 조회할 때, content(내용)이 필요하므로 필드에 기입합니다.

[Docker] No space left on device

Tue, 02 Apr 2024 15:15:40 GMT

📌 문제

📖 문제 발생

Jenkins CI/CD 빌드/배포 자동화 수행 중 오류가 발생

No space left on device

📖 문제 원인

Jenkins CI/CD가 반복적으로 수행되는 과정에서 Build Cache가 쌓이면서 문제 발생
$ docker system df: 현재 사용중인 이미지, 컨테이너 및 볼륨이 얼마나 많은 공간을 사용하고 있는지 확인할 수 있는 명령어. 뒤에 -v (vervose)옵션을 추가하면 사용하지 않는 이미지와 컨테이너도 확인 가능

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/root       311G  310G  284M 100% /
...

$ sudo docker system df -v

Images space usage:

REPOSITORY       TAG       IMAGE ID       CREATED        SIZE      SHARED SIZE   UNIQUE SIZE   CONTAINERS
server/backend   latest    aa4d75651096   4 hours ago    2.36GB    0B            2.356GB       1
server/flask     latest    2df4d4b0373f   9 hours ago    1.71GB    0B            1.714GB       1
server/sdwebui   latest    97b0cc844eb6   13 days ago    12.9GB    0B            12.9GB        1
server/jenkins   latest    53eb4ac17ccf   3 weeks ago    996MB     0B            996.1MB       1
redis            latest    170a1e90f843   2 months ago   138MB     0B            137.7MB       1

Containers space usage:

CONTAINER ID   IMAGE            COMMAND                  LOCAL VOLUMES   SIZE      CREATED       STATUS       NAMES
51fea23b7f65   server/backend   "java -Dfile.encodin…"   0               69.8MB    4 hours ago   Up 4 hours   server-backend
0bcf716ad266   server/flask     "python -m app"          0               75.9kB    9 hours ago   Up 9 hours   peaceful_poincare
ec6a6ba85069   redis:latest     "docker-entrypoint.s…"   1               970B      12 days ago   Up 12 days   server-redis
d45a7633117c   server/sdwebui   "/bin/sh -c './webui…"   0               1.52MB    13 days ago   Up 13 days   server-sdwebui
b4f0930a3620   server/jenkins   "/usr/bin/tini -- /u…"   0               2.68GB    2 weeks ago   Up 2 weeks   server-jenkins

Local Volumes space usage:

VOLUME NAME                                                        LINKS     SIZE
frontend                                                           0         986.1MB
99fbae4584bbc073085c13eb3521a2b8fc8e473e49d8e416bd0c2a0fad52d622   1         692B

Build cache usage: 239.1GB

CACHE ID       CACHE TYPE     SIZE      CREATED        LAST USED      USAGE     SHARED
tedxqgtdxyuo   regular        0B        3 weeks ago    3 weeks ago    1         true
o0ctbsb203zx   regular        0B        3 weeks ago    3 weeks ago    1         true
rj7x1gryphqf   regular        0B        3 weeks ago    3 weeks ago    1         true
lwkf9nf8n56i   regular        0B        3 weeks ago    3 weeks ago    1         true
9xgrulsw4agg   regular        0B        3 weeks ago    3 weeks ago    1         true
...
wnxw3nbkq9lq   source.local   1.08kB    13 days ago    4 hours ago    72        false
kk63u2877y75   source.local   1.43GB    13 days ago    4 hours ago    72        false
u961phqnm9hk   source.local   0B        13 days ago    4 hours ago    72        false
yi0bk5rb8196   regular        1.43GB    4 hours ago    4 hours ago    1         false
qx24ltqc2i91   regular        374MB     4 hours ago    4 hours ago    1         false

📌 해결

📖 해결 방법

$ docker {option} prune: 사용하지 않는 컨테이너 이미지를 제거하는 명령어.

docker volume prune: 미사용 볼륨 제거
docker container prune: 미사용 컨테이너 제거
docker image prune: 미사용 이미지 제거
docker system prune: 미사용 중인 이미지, 컨테이너, 볼륨 모두 제거

$ sudo docker system prune
WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all dangling images
  - unused build cache

Are you sure you want to continue? [y/N] y
Deleted build cache objects:
srcnm8ftb1v79f6ettaf2bb6z
w8680tyap8d997hqucw9q6r44
pqtcfdmmueoyvjn7k3d5n0kat
i9opfym5x8wqm66huz0hxqu8e
v36akpatuyaoa7xgwb5sq89zi
...
972yylz5mtkcx7jpk2aknp1go
ocgyuijoqbqozrtiryt5xsuk6
i44z9mydueux37f9axhgecs1p
kmxd7dz6hu9izv9ww8egsdfzf
rp8d0tqyi6f8g0fftmjaqrb2a

Total reclaimed space: 239.1GB

📖 결과 확인

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/root       311G   76G  235G  25% /
...

$ sudo docker system df -v
Images space usage:

REPOSITORY       TAG       IMAGE ID       CREATED        SIZE      SHARED SIZE   UNIQUE SIZE   CONTAINERS
server/backend   latest    aa4d75651096   4 hours ago    2.36GB    0B            2.356GB       1
server/flask     latest    2df4d4b0373f   9 hours ago    1.71GB    0B            1.714GB       1
server/sdwebui   latest    97b0cc844eb6   13 days ago    12.9GB    0B            12.9GB        1
server/jenkins   latest    53eb4ac17ccf   3 weeks ago    996MB     0B            996.1MB       1
redis            latest    170a1e90f843   2 months ago   138MB     0B            137.7MB       1

Containers space usage:

CONTAINER ID   IMAGE            COMMAND                  LOCAL VOLUMES   SIZE      CREATED       STATUS       NAMES
51fea23b7f65   server/backend   "java -Dfile.encodin…"   0               69.8MB    4 hours ago   Up 4 hours   server-backend
0bcf716ad266   server/flask     "python -m app"          0               75.9kB    9 hours ago   Up 9 hours   peaceful_poincare
ec6a6ba85069   redis:latest     "docker-entrypoint.s…"   1               970B      12 days ago   Up 12 days   server-redis
d45a7633117c   server/sdwebui   "/bin/sh -c './webui…"   0               1.52MB    13 days ago   Up 13 days   server-sdwebui
b4f0930a3620   server/jenkins   "/usr/bin/tini -- /u…"   0               2.68GB    2 weeks ago   Up 2 weeks   server-jenkins

Local Volumes space usage:

VOLUME NAME                                                        LINKS     SIZE
frontend                                                           0         986.1MB
99fbae4584bbc073085c13eb3521a2b8fc8e473e49d8e416bd0c2a0fad52d622   1         692B

Build cache usage: 0B

CACHE ID       CACHE TYPE   SIZE      CREATED       LAST USED     USAGE     SHARED
tedxqgtdxyuo   regular      0B        3 weeks ago   3 weeks ago   1         true
o0ctbsb203zx   regular      0B        3 weeks ago   3 weeks ago   1         true
rj7x1gryphqf   regular      0B        3 weeks ago   3 weeks ago   1         true
lwkf9nf8n56i   regular      0B        3 weeks ago   3 weeks ago   1         true
9xgrulsw4agg   regular      0B        3 weeks ago   3 weeks ago   1         true
...
nasnj8zhsxh2   regular      0B        8 days ago    9 hours ago   26        true
jjsnpxdic89f   regular      173MB     9 hours ago   9 hours ago   1         true
xu7sjqzi7lbr   regular      0B        5 days ago    4 hours ago   50        true
u3han9rdyypr   regular      1.53GB    4 hours ago   4 hours ago   1         true
ua8dcwafo6s4   regular      172MB     4 hours ago   4 hours ago   1         true

[AWS/EC2] AWS EC2 Jenkins CI/CD

Thu, 14 Mar 2024 08:02:56 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 Jenkins Plugin 설치

NodeJS, GitLab 플러그인 설치

📌 Jenkins GitLab 설정

📖 GitLab AccessToken 발급

📖 Jenkins Credential 설정

📖 Jenkins System 설정

📖 Jenkins Tools NodeJS 설정

📌 React Dockerfile 작성

/frontend 에 Dockerfile 작성

# Node.js 공식 이미지 사용. 버전 20.11.1, 경량화된 Alpine Linux 기반
FROM node:20.11.1-alpine

# 작업 디렉토리 설정. 컨테이너 내 앱의 기본 경로
WORKDIR /home/app

# 현재 디렉토리의 package.json과 package-lock.json 파일이 존재한다면
# 컨테이너의 작업 디렉토리로 package.json과 package-lock.json 복사
COPY package*.json ./

# package.json에 명시된 애플리케이션 의존성 설치
# package-lock.json이 있을 경우 더 빠르게 설치 가능
RUN npm install

# 현재 디렉토리의 모든 파일을 컨테이너의 작업 디렉토리로 복사
COPY . .

# React 애플리케이션 빌드
RUN npm run build

📌 SpringBoot Dockerfile 작성

/backend 에 Dockerfile 작성

# OpenJDK 17을 포함하는 경량화된 Alpine Linux 베이스 이미지 사용
FROM openjdk:17-jdk-alpine

# 컨테이너 내부의 작업 디렉토리를 /home/app로 설정
WORKDIR /home/app

# 호스트 시스템의 SpringBoot 애플리케이션 JAR 파일을 컨테이너 내부 작업 디렉토리로 복사
COPY build/libs/*.jar app.jar

# 컨테이너가 시작될 때 실행될 명령어 정의, 작업 디렉토리 /home/app/app.jar 파일 실행
ENTRYPOINT ["java","-jar","./app.jar"]

# 컨테이너의 8080 포트를 외부로 노출
EXPOSE 8080

📌 Jenkins Pipeline 설정

📖 Jenkins Credential 설정

📖 Pipeline 생성

초록색 박스로 표시된 GitLab webhook URL을 잘 기록해둔다. 초록색 박스로 표시된 고급 탭에서 Generate한 Secret token을 잘 기록해둔다.

git branch: 'master', credentialsId: 'YOUR_CREDENTIAL', url: 'https://'

pipeline {
    agent any

    tools {
        nodejs 'nodejs-20.11.1'
    }

    // 필요한 변수 설정
    environment {
        PROJECT_DIR = 'your_project_directory_name'
        DOCKER_REGISTRY = 'your_docker_registry_url'

        BACKEND_IMAGE_NAME = 'server/backend'
        FRONTEND_IMAGE_NAME = 'server/frontend'

        BACKEND_CONTAINER_NAME = 'server-backend'
        FRONTEND_CONTAINER_NAME = 'server-frontend'
    }


    stages {
        stage('Checkout') {
            steps {
                echo 'Starting Repository Checkout'

                git url: 'https://',
                credentialsId: 'YOUR_CREDENTIAL', branch: 'master'

                echo 'Repository Checkout Completed'
            }
        }

        stage('Build Frontend') {
            steps {
                echo 'Starting Frontend Build Process'

                dir('frontend') {
                    sh 'docker ps -aqf "name=${FRONTEND_CONTAINER_NAME}" && docker stop ${FRONTEND_CONTAINER_NAME} && docker rm ${FRONTEND_CONTAINER_NAME}'
                    sh 'docker images -q ${FRONTEND_IMAGE_NAME} && docker rmi ${FRONTEND_IMAGE_NAME}'
                    sh 'docker build -t ${FRONTEND_IMAGE_NAME} .'
                }

                echo 'Frontend Build Completed Successfully'
            }
            post {
                success {
                    script {
                        echo 'Build Frontend Success'
                    }
                }
                failure {
                    script {
                        echo 'Build Frontend Failed'
                    }
                }
            }
        }

        stage('Test Frontend') {
            steps {
                echo 'Starting Frontend Tests'

                dir('frontend') {
                    sh 'npm test'
                }

                echo 'Frontend Tests Completed'
            }
            post {
                success {
                    script {
                        echo 'Test Frontend Success'
                    }
                }
                failure {
                    script {
                        echo 'Test Frontend Failed'
                    }
                }
            }
        }

        stage('Deploy Frontend') {
            steps {
                echo 'Deploying Frontend'

                sh "docker run -d -p 3000:3000 --name ${FRONTEND_CONTAINER_NAME} ${FRONTEND_IMAGE_NAME}"

                echo 'Frontend Deployed Successfully'
            }
            post {
                success {
                    script {
                        echo 'Deploy Frontend Success'
                    }
                }
                failure {
                    script {
                        echo 'Deploy Frontend Failed'
                    }
                }
            }
        }

        stage('Build Backend') {
            steps {
                echo 'Starting Backend Build Process'

                dir('backend') {
                    sh 'chmod +x ./gradlew'
                    sh './gradlew clean build'

                    sh 'docker ps -aqf "name=${BACKEND_CONTAINER_NAME}" && docker stop ${BACKEND_CONTAINER_NAME} && docker rm ${BACKEND_CONTAINER_NAME}'
                    sh 'docker images -q ${BACKEND_IMAGE_NAME} && docker rmi ${BACKEND_IMAGE_NAME}'
                    sh 'docker build -t ${BACKEND_IMAGE_NAME} .'
                }

                echo 'Backend Build Completed Successfully'
            }
            post {
                success {
                    script {
                        echo 'Build Backend Success'
                    }
                }
                failure {
                    script {
                        echo 'Build Backend Failed'
                    }
                }
            }
        }

        stage('Test Backend') {
            steps {
                echo 'Starting Backend Tests'

                dir('backend') {
                    sh './gradlew test'
                }

                echo 'Backend Tests Completed'
            }
            post {
                success {
                    script {
                        echo 'Test Backend Success'
                    }
                }
                failure {
                    script {
                        echo 'Test Backend Failed'
                    }
                }
            }
        }

        stage('Deploy Backend') {
            steps {
                echo 'Deploying Backend'

                sh "docker run -d -p 8080:8080 --name ${BACKEND_CONTAINER_NAME} ${BACKEND_IMAGE_NAME}"

                echo 'Backend Deployed Successfully'
            }
            post {
                success {
                    script {
                        echo 'Deploy Backend Success'
                    }
                }
                failure {
                    script {
                        echo 'Deploy Backend Failed'
                    }
                }
            }
        }
    }

    post {
        always {
            echo 'Pipeline Execution Complete.'
        }
        success {
            echo 'Pipeline Execution Success.'
            script {
                echo '빌드/배포 Success'
            }
        }
        failure {
            echo 'Pipeline Execution Failed.'
            script {
                echo '빌드/배포 Failed'
            }
        }
    }
}

📖 GitLab Webhook 추가

URL: 위에서 기록해둔 GitLab webhook URL
Secret token: 위에서 기록해둔 Secret token

📌 Mattermost Webhook 설정

📖 Mattermost Webhook 추가

📖 Jenkins Mattermost Plugin 설치

📖 Jenkins System 설정

Endpoint: Incoming Webhook URL
Channel: Incoming Webhook을 추가할 때 선택했던 채널 이름 (초록색 박스 안의 주소)
Build Server URL: Jenkins URL (자동으로 입력되어 있을 것이다.)

📖 공통 함수 정의

// 공통 함수 정의
def sendMattermostNotification(String stage, String status) {
    script {
        def AUTHOR_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
        def AUTHOR_NAME = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()

        def color = (status == 'Success') ? 'good' : 'danger'
        def message = "${stage} ${status}: ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${AUTHOR_ID}(${AUTHOR_NAME})\n(<${env.BUILD_URL}|Details>)"
        def endpoint = 'https://your_notification_service_endpoint'
        def channel = 'your_notification_service_channel'

        mattermostSend (
            color: color,
            message: message,
            endpoint: endpoint,
            channel: channel,
        )
    }
}

pipeline {
    agent any

    ...
}

📖 Pipeline 적용

// 공통 함수 정의
def sendMattermostNotification(String stage, String status) {
    script {
        def AUTHOR_ID = sh(script: "git show -s --pretty=%an", returnStdout: true).trim()
        def AUTHOR_NAME = sh(script: "git show -s --pretty=%ae", returnStdout: true).trim()

        def color = (status == 'Success') ? 'good' : 'danger'
        def message = "${stage} ${status}: ${env.JOB_NAME} #${env.BUILD_NUMBER} by ${AUTHOR_ID}(${AUTHOR_NAME})\n(<${env.BUILD_URL}|Details>)"
        def endpoint = 'https://your_notification_service_endpoint'
        def channel = 'your_notification_service_channel'

        mattermostSend (
            color: color,
            message: message,
            endpoint: endpoint,
            channel: channel,
        )
    }
}

pipeline {
    agent any

    tools {
        nodejs 'nodejs-20.11.1'
    }

    // 필요한 변수 설정
    environment {
        PROJECT_DIR = 'your_project_directory_name'
        DOCKER_REGISTRY = 'your_docker_registry_url'

        BACKEND_IMAGE_NAME = 'server/backend'
        FRONTEND_IMAGE_NAME = 'server/frontend'

        BACKEND_CONTAINER_NAME = 'server-backend'
        FRONTEND_CONTAINER_NAME = 'server-frontend'
    }


    stages {
        stage('Checkout') {
            steps {
                echo 'Starting Repository Checkout'

                git url: 'https://',
                credentialsId: 'YOUR_CREDENTIAL', branch: 'master'

                echo 'Repository Checkout Completed'
            }
        }

        stage('Build Frontend') {
            steps {
                echo 'Starting Frontend Build Process'

                dir('frontend') {
                    sh 'docker ps -aqf "name=${FRONTEND_CONTAINER_NAME}" && docker stop ${FRONTEND_CONTAINER_NAME} && docker rm ${FRONTEND_CONTAINER_NAME}'
                    sh 'docker images -q ${FRONTEND_IMAGE_NAME} && docker rmi ${FRONTEND_IMAGE_NAME}'
                    sh 'docker build -t ${FRONTEND_IMAGE_NAME} .'
                }

                echo 'Frontend Build Completed Successfully'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Build Frontend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Build Frontend', 'Failed')
                    }
                }
            }
        }

        stage('Test Frontend') {
            steps {
                echo 'Starting Frontend Tests'

                dir('frontend') {
                    sh 'npm test'
                }

                echo 'Frontend Tests Completed'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Test Frontend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Test Frontend', 'Failed')
                    }
                }
            }
        }

        stage('Deploy Frontend') {
            steps {
                echo 'Deploying Frontend'

                sh "docker run -d -p 3000:3000 --name ${FRONTEND_CONTAINER_NAME} ${FRONTEND_IMAGE_NAME}"

                echo 'Frontend Deployed Successfully'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Deploy Frontend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Deploy Frontend', 'Failed')
                    }
                }
            }
        }

        stage('Build Backend') {
            steps {
                echo 'Starting Backend Build Process'

                dir('backend') {
                    sh 'chmod +x ./gradlew'
                    sh './gradlew clean build'

                    sh 'docker ps -aqf "name=${BACKEND_CONTAINER_NAME}" && docker stop ${BACKEND_CONTAINER_NAME} && docker rm ${BACKEND_CONTAINER_NAME}'
                    sh 'docker images -q ${BACKEND_IMAGE_NAME} && docker rmi ${BACKEND_IMAGE_NAME}'
                    sh 'docker build -t ${BACKEND_IMAGE_NAME} .'
                }

                echo 'Backend Build Completed Successfully'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Build Backend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Build Backend', 'Failed')
                    }
                }
            }
        }

        stage('Test Backend') {
            steps {
                echo 'Starting Backend Tests'

                dir('backend') {
                    sh './gradlew test'
                }

                echo 'Backend Tests Completed'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Test Backend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Test Backend', 'Failed')
                    }
                }
            }
        }

        stage('Deploy Backend') {
            steps {
                echo 'Deploying Backend'

                sh "docker run -d -p 8080:8080 --name ${BACKEND_CONTAINER_NAME} ${BACKEND_IMAGE_NAME}"

                echo 'Backend Deployed Successfully'
            }
            post {
                success {
                    script {
                        sendMattermostNotification('Deploy Backend', 'Success')
                    }
                }
                failure {
                    script {
                        sendMattermostNotification('Deploy Backend', 'Failed')
                    }
                }
            }
        }
    }

    post {
        always {
            echo 'Pipeline Execution Complete.'
        }
        success {
            echo 'Pipeline Execution Success.'
            script {
                sendMattermostNotification('빌드/배포', 'Success')
            }
        }
        failure {
            echo 'Pipeline Execution Failed.'
            script {
                sendMattermostNotification('빌드/배포', 'Failed')
            }
        }
    }
}

[AWS/EC2] AWS EC2 MySQL 설치

Thu, 14 Mar 2024 01:57:26 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 MySQL 설치

root 비밀번호 변경
새 계정 추가 및 외부접속 허용
Shell Script를 사용하여 자동화

📖 Shell Script 작성

install_mysql.sh

#!/bin/bash

# 변수명 설정
ROOT_PASSWORD='your_root_password'
NEW_USERNAME='your_new_mysql_username'
NEW_PASSWORD='your_new_mysql_password'

# 방화벽 설정
if sudo ufw status | grep -qw inactive; then
    echo "방화벽이 비활성화되어 있습니다. 방화벽을 활성화합니다."
    sudo ufw enable
fi
sudo ufw allow 3306

# MySQL 설치
echo "MySQL 설치를 시작합니다..."
sudo apt-get update
sudo apt-get install -y mysql-server

# MySQL 서비스 시작
sudo systemctl start mysql
sudo systemctl enable mysql

# 루트 비밀번호 설정 및 보안 설치 실행
sudo mysql -e "ALTER USER 'root'@'localhost' IDENTIFIED BY '${ROOT_PASSWORD}';"
sudo mysql -e "FLUSH PRIVILEGES;"

# 사용자 추가 스크립트
sudo mysql -e "CREATE USER '${NEW_USERNAME}'@'%' IDENTIFIED BY '${NEW_PASSWORD}';"
sudo mysql -e "GRANT ALL PRIVILEGES ON *.* TO '${NEW_USERNAME}'@'%' WITH GRANT OPTION;"
sudo mysql -e "FLUSH PRIVILEGES;"

# MySQL 설정 파일에서 bind-address 값을 0.0.0.0으로 변경하여 어느 주소에서든 접근 가능하도록 설정
sudo sed -i '/bind-address/s/^#//g' /etc/mysql/mysql.conf.d/mysqld.cnf
sudo sed -i 's/127.0.0.1/0.0.0.0/g' /etc/mysql/mysql.conf.d/mysqld.cnf

# MySQL 서비스 재시작
sudo systemctl restart mysql

echo "MySQL 설치 및 사용자 추가가 완료되었습니다."

% 권한: 모든 IP 접근 허용, MySQL Workbench 등 외부접속이 필요한 경우 사용
localhost 권한: localhost IP 접근 허용, root 계정 등 외부접속으로부터 보안상 보호해야할 경우 사용

📖 Shell Script 실행

$ sudo chmod +x install_mysql.sh
$ ./install_mysql.sh

📌 MySQL 삭제

Shell Script를 사용하여 자동화
MySQL 클린 삭제

📖 Shell Script 작성

uninstall_mysql.sh

#!/bin/bash

# 사용자에게 MySQL 삭제 확인 메시지 표시
echo "MySQL 클린 삭제를 시작합니다. 모든 MySQL 데이터가 제거됩니다."
read -rp "정말로 MySQL을 클린 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다. (y/n): " confirm

if [[ $confirm == [yY] || $confirm == [yY][eE][sS] ]]; then
    echo "MySQL 클린 삭제를 시작합니다..."

    # MySQL 서비스 중지
    sudo systemctl stop mysql

    # MySQL 패키지 및 관련 패키지 제거
    sudo apt-get remove --purge -y mysql-server mysql-client mysql-common mysql-server-core-* mysql-c>    sudo apt-get autoremove -y
    sudo apt-get autoclean -y

    # MySQL 설정 파일 및 데이터베이스 디렉토리 삭제
    sudo rm -rf /etc/mysql /var/lib/mysql

    # MySQL 로그 파일 삭제
    sudo rm -rf /var/log/mysql

    # MySQL 사용자 및 그룹 삭제 (선택적)
    sudo deluser mysql
    sudo delgroup mysql

    echo "MySQL이 시스템에서 완전히 제거되었습니다."
else
    echo "MySQL 클린 삭제가 취소되었습니다."

📖 Shell Script 실행

$ sudo chmod +x uninstall_mysql.sh
$ ./uninstall_mysql.sh

[AWS/EC2] AWS EC2 Docker Jenkins 설치

Tue, 12 Mar 2024 17:22:31 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 Docker Jenkins 수동설치

개발자가 직접 명령어를 실행하며 설치하는 방법

📖 Docker Jenkins Image Pull

DockerHub에 존재하는 이미지를 pull
아래 세 개 중 어느 걸 사용해도 무방

실행하지 않아도 상관없음

$ sudo docker pull jenkins/jenkins:lts
$ sudo docker pull jenkins/jenkins:jdk17
$ sudo docker pull jenkins/jenkins:lts-jdk17 (권장)

📖 Docker Jenkins Container 실행

$ sudo docker run -d -u root \
    -p 8081:8080 -p 50000:50000 \
    -v /var/jenkins_home:/var/jenkins_home \
    -v /var/run/docker.sock:/var/run/docker.sock \
    --name server-jenkins jenkins/jenkins:lts-jdk17
    # --name server-jenkins jenkins/jenkins:lts
    # --name server-jenkins jenkins/jenkins:jdk17

-u 실행할 계정 지정
-d detached mode, 흔히 말하는 백그라운드 모드
-p 호스트와 컨테이너의 포트를 연결 (포워딩)
-v 호스트와 컨테이너의 디렉토리를 연결 (마운트)
--name 컨테이너 이름 설정

맨 마지막 jenkins/jenkins:lts-jdk17 은 위에서 pull한 이미지 이름
만약, 위에서 pull한 이미지가 없을 경우, DockerHub 에서 자동으로 pull

📖 Docker Jenkins Docker CLI 설치

root 계정은 sudo 명령어 없음
2024 Docker 공식문서 기준 설치방법 채용
Docker Jenkins Container는 debian 계열 linux
[Docker 공식문서] https://docs.docker.com/engine/install/debian/
[DockerHub 공식문서] https://docs.docker.com/engine/install/debian/

# Docker Container 접속
$ sudo docker exec -it server-jenkins /bin/bash

# Add Docker's official GPG key:
$ apt-get update
$ apt-get install ca-certificates curl
$ install -m 0755 -d /etc/apt/keyrings
$ curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
$ chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
    $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker CLI 설치
$ apt-get update
$ apt-get install -y docker-ce docker-ce-cli containerd.io

📌 Docker Jenkins 자동설치

Dockerfile과 Shell Script로 모든 설치과정을 자동화
Dockerfile과 Shell Script가 같은 경로에 위치해야 함

$ mkdir jenkins
$ cd jenkins

$ sudo nano Dockerfile
$ sudo nano install_jenkins.sh

$ sudo chmod +x install_jenkins.sh
$ ./install_jenkins.sh

📖 Dockerfile 작성

root 계정은 sudo 명령어 없음
2024 Docker 공식문서 기준 설치방법 채용
Docker Jenkins Container는 debian 계열 linux
[Docker 공식문서] https://docs.docker.com/engine/install/debian/
[DockerHub 공식문서] https://docs.docker.com/engine/install/debian/

Dockerfile

# 기본 이미지 설정
FROM jenkins/jenkins:lts-jdk17

# root 계정으로 변경
USER root

# Docker 공식 GPG 키 추가 및 Docker 저장소 설정
RUN apt-get update && \
    apt-get install -y ca-certificates curl && \
    install -m 0755 -d /etc/apt/keyrings && \
    curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc && \
    chmod a+r /etc/apt/keyrings/docker.asc && \
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
    $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Docker CLI 설치
RUN apt-get update && \
    apt-get install -y docker-ce docker-ce-cli containerd.io

# 컨테이너 계정 및 그룹 권한 설정을 위한 변수
# ARG GROUP_GID=998
# ARG USER_UID=1000

# 컨테이너 계정 및 그룹 권한 설정
# RUN groupmod -g ${GROUP_GID} docker && \ # docker 그룹 GID를 변경, 호스트와 일치
# RUN usermod -u ${USER_UID} jenkins && \  # jenkins 계정 UID를 변경, 호스트와 일치
#     usermod -aG docker jenkins           # jenkins 계정을 docker 그룹에 추가

# jenkins 계정으로 변경 (Jenkins 기본 계정)
# USER jenkins

컨테이너 사용자 (jenkins)가 호스트 파일에 접근 가능하도록 컨테이너 사용자 (jenkins) UID를 변경하여 호스트 설정과 일치시키고 컨테이너 그룹 (docker) GID를 변경하여 호스트 설정과 일치시킨다. 마지막으로 jenkins 계정을 docker 그룹에 추가한다.

참고로 UID와 GID는 아래와 같이 확인할 수 있다. 계정 UID는 호스트의 /etc/passwd 또는 $ id -u [계정명] 그룹 GID는 호스트의 /etc/group 또는 $ getent group [그룹명] [Reference] https://bitgadak.tistory.com/3

📖 Shell Script 작성

install_jenkins.sh

#!/bin/bash

IMAGE_NAME="server/jenkins"
CONTAINER_NAME="server-jenkins"

IMAGE_ID=$(sudo docker images -q $IMAGE_NAME)
CONTAINER_ID=$(sudo docker ps -aqf "name=$CONTAINER_NAME")

echo ">>> CURRENT DOCKER INFORMATION:"
echo "$IMAGE_NAME IMAGE_ID: $IMAGE_ID"
echo -e "$CONTAINER_NAME CONTAINER_ID: $CONTAINER_ID\n"


# Stop & Remove Existing Container
echo ">>> $CONTAINER_NAME 컨테이너 실행 여부 검사 시작..."
if [ ! -z "$CONTAINER_ID" ]; then
    # docker stop $(docker ps -aq --filter "name=$CONTAINER_NAME")
    # docker rm $(docker ps -ap --filter "name=$CONTAINER_NAME")
    echo -e ">>> 실행중인 $CONTAINER_NAME 컨테이너 중지 및 삭제 시작...\n"

    echo ">>> 실행중인 $CONTAINER_NAME 컨테이너 중지 시작..."
    sudo docker stop $CONTAINER_ID || {
        echo ">>> $CONTAINER_NAME 컨테이너 중지 실패."
        exit 1
    }
    echo -e ">>> 실행중인 $CONTAINER_NAME 컨테이너 중지 완료.\n"

    echo ">>> 중지상태인 $CONTAINER_NAME 컨테이너 삭제 시작..."
    sudo docker rm $CONTAINER_ID || {
        echo ">>> $CONTAINER_NAME 컨테이너 삭제 실패."
        exit 1
    }
    echo -e ">>> 중지상태인 $CONTAINER_NAME 컨테이너 삭제 완료.\n"

    echo ">>> 실행중인 $CONTAINER_NAME 컨테이너 중지 및 삭제 완료."
fi
echo -e ">>> $CONTAINER_NAME 컨테이너 실행 여부 검사 완료.\n"


# Remove Existing Docker Image
echo ">>> $IMAGE_NAME 이미지 존재 여부 검사 시작..."
if [ ! -z "$IMAGE_ID" ]; then
    # docker rmi -f $(docker image -q $IMAGE_NAME)
    echo ">>> 기존 $IMAGE_NAME 이미지 삭제 시작..."
    sudo docker rmi $IMAGE_ID || {
        echo ">>> 기존 $IMAGE_NAME 이미지 삭제 실패."
        exit 1
    }
    echo ">>> 기존 $IMAGE_NAME 이미지 삭제 완료."
fi
echo -e ">>> $IMAGE_NAME 이미지 존재 여부 검사 완료.\n"


# Build Docker Image

# 현재 사용자의 UID와 Docker 그룹의 GID 추출
GROUP_GID=$(getent group docker | cut -d: -f3)
USER_UID=$(id -u $USER)

# Docker 이미지를 빌드하면서 사용자 UID와 그룹 GID를 인자로 전달
echo ">>> $IMAGE_NAME 이미지 빌드 시작..."
sudo docker build -t $IMAGE_NAME . \
  --build-arg USER_UID=$USER_UID \
  --build-arg GROUP_GID=$GROUP_GID || {
    echo ">>> $IMAGE_NAME 이미지 빌드 실패."
    exit 1
}
echo -e ">>> $IMAGE_NAME 이미지 빌드 완료.\n"


# Run Docker Container (USER jenkins)
echo ">>> $CONTAINER_NAME 컨테이너 실행 시작..."
sudo chown -R 1000:1000 /var/jenkins_home
sudo docker run -d \
    -p 8081:8080 -p 50000:50000 \
    -v /var/jenkins_home:/var/jenkins_home \
    -v /var/run/docker.sock:/var/run/docker.sock \
    --name $CONTAINER_NAME $IMAGE_NAME || {
        echo ">>> $CONTAINER_NAME 컨테이너 실행 실패."
        exit 1
    }
echo ">>> $CONTAINER_NAME 컨테이너 실행 완료."


## Run Docker Container (USER root)
#echo ">>> $CONTAINER_NAME 컨테이너 실행 시작..."
#sudo docker run -d -u root \
#    -p 8081:8080 -p 50000:50000 \
#    -v /var/jenkins_home:/var/jenkins_home \
#    -v /var/run/docker.sock:/var/run/docker.sock \
#    --name $CONTAINER_NAME $IMAGE_NAME || {
#        echo ">>> $CONTAINER_NAME 컨테이너 실행 실패."
#        exit 1
#    }
#echo ">>> $CONTAINER_NAME 컨테이너 실행 완료."

📖 Shell Script 실행

Dockerfile과 Shell Script가 같은 경로에 위치해야 함

$ mkdir jenkins
$ cd jenkins

$ sudo nano Dockerfile
$ sudo nano install_jenkins.sh

$ sudo chmod +x install_jenkins.sh
$ ./install_jenkins.sh

📌 Docker Jenkins 설정

http://:8081
Jenkins 초기 비밀번호 확인
Jenkins 초기 접속 설정

📖 Jenkins 접속

아래 명령어들 중 하나를 선택해 초기 비밀번호 확인
/var/jenkins_home 경로는 마운트된 볼륨이므로 호스트 서버에서도 확인 가능

# 호스트 서버에서 확인
$ sudo cat /var/jenkins_home/secrets/initialAdminPassword

# Docker Jenkins 처음 실행 로그로 확인
$ sudo docker logs server-jenkins

# Docker Jenkins 컨테이너에 접속하여 확인
$ sudo docker exec -it server-jenkins /bin/bash
$ cat /var/jenkins_home/secrets/initialAdminPassword

# Docker Jenkins 컨테이너에 명령어로 확인
$ sudo docker exec server-jenkins cat /var/jenkins_home/secrets/initialAdminPassword

📖 Jenkins 초기 설정

Install suggested plugins 선택
아이디, 비밀번호, 비밀번호 확인, 이름, 이메일 입력

[AWS/EC2] AWS EC2 Docker 설치

Mon, 11 Mar 2024 07:55:58 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 Docker 설치

2024 Docker 공식 문서 기반 설치 방법

[Reference]: Docker Documents (https://docs.docker.com/engine/install/ubuntu/)

📖 1. Docker apt repository 설정

# Add Docker's official GPG key:
$ sudo apt-get update
$ sudo apt-get install ca-certificates curl
$ sudo install -m 0755 -d /etc/apt/keyrings
$ sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
$ sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
$ sudo apt-get update

📖 2. Docker 패키지 설치

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

📖 3. Docker 패키지 설치 확인

$ sudo docker run hello-world

[AWS/EC2] AWS EC2 인스턴스 시작

Sat, 02 Mar 2024 07:05:34 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 EC2 프리티어 요금

AWS(Amazon Web Services) 가입 후 12개월 간 프리티어 제공
프리티어는 무제한 무료가 아닌 조건부 무료임에 주의
- EC2: 계정 당 매월 750시간 무료
- EBS: 계정 당 30GB 무료
- RDS: 계정 당 20GB 한도 내에서 매월 750시간 무료
- S3: 계정 당 5GB 무료, GET 요청 20,000건 무료, PUT 요청 2,000건 무료
- 탄력적 IP: 인스턴스 당 1개의 탄력적 IP 무료, 단 실행중인 인스턴스에 한함
아래의 안내사항을 정독하고, 과금발생시 아래의 링크를 참고하여 문제해결

[ AWS 공식 프리티어 요금안내 ] https://aws.amazon.com/ko/free/?nc2=h_ql_pr_ft&all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc&awsf.Free%20Tier%20Types=*all&awsf.Free%20Tier%20Categories=*all

[ AWS 서비스 별 프리티어 과금안내 ] https://inpa.tistory.com/entry/AWS-%F0%9F%92%B0-%ED%94%84%EB%A6%AC%ED%8B%B0%EC%96%B4-%EC%9A%94%EA%B8%88-%ED%8F%AD%ED%83%84-%EB%B0%A9%EC%A7%80-%F0%9F%92%B8-%EB%AC%B4%EB%A3%8C-%EC%82%AC%EC%9A%A9%EB%9F%89-%EC%A0%95%EB%A6%AC#s3

[ AWS EC2 요금제 및 월별요금 계산법 ] https://duckracoon.tistory.com/entry/AWS-%EC%9A%94%EA%B8%88%EC%A0%95%EB%A6%AC [ AWS EBS/RDS/ElasticIP 프리티어 과금예시 ] https://gun0912.tistory.com/45 [ AWS 프리티어 사용량 확인 ] https://hnev.tistory.com/47 [ RDS DB 백업 스토리지 스냅샷 제거 및 탄력적 IP 삭제 ] https://blog.naver.com/baekmg1988/221608368784

📌 EC2 프리티어 인스턴스 생성

[ EC2 인스턴스 생성 및 SSH 접속 ] https://ksh-coding.tistory.com/72

📖 인스턴스 시작 버튼 클릭

AWS EC2 리전(Region, 지역 ) 서울로 변경
인스턴스 시작 버튼 클릭

📖 인스턴스 설정

인스턴스 이름 입력
애플리케이션 및 OS 이미지(Amazon Machine Image, AMI) 선택
인스턴스 유형 선택
키 페어 생성
네트워크 설정
스토리지 구성
인스턴스 생성

📌 탄력적 IP (고정 IP) 설정

탄력적 IP
탄력적 IP 주소 할당
탄력적 IP 주소 연결

📖 탄력적 IP 주소 할당

📖 탄력적 IP 주소 연결

📌 Windows Pemkey 권한 설정

Windows11에서 바로 사용 가능
Windows10에서 권한 수정 후 사용 가능
- 마우스 우클릭 - 속성 - 보안 탭 - 고급
- 상속 사용 안 함 - 이 개체에서 상속된 사용 권한을 모두 제거합니다.
- 추가 - 보안 주체 선택 - 윈도우 계정명 - 확인 - 확인 - 확인 - 확인

$ cd ./Desktop/{keypair_downloaded_path}
$ ssh -i YourKeyPairName.pem ubuntu@YourElasticIP

[AWS/EC2] AWS EC2 초기 설정

Fri, 01 Mar 2024 11:40:13 GMT

※ 읽기에 앞서

본 시리즈는 작성자의 이해와 경험을 바탕으로 실습 위주의 설명을 기반으로 작성되었습니다.
실습 위주의 이해를 목표로 하기 때문에 다소 과장이 많고 생략된 부분이 많을 수 있습니다.
따라서, 이론적으로 미흡한 부분이 있을 수 있는 점에 대해 유의하시기 바랍니다.

또한, 본 시리즈는 ChatGPT의 도움을 받아 작성되었습니다.
수 차례의 질문을 통해 도출된 여러가지 다양한 방식의 코드를 종합하여
작성자의 이해와 경험을 바탕으로 가장 정석으로 생각되는 코드를 재정립하였습니다.

📌 서버 시간 변경

$ sudo timedatectl set-timezone Asia/Seoul
$ timedatectl
$ date

📌 미러 서버 변경

미러 서버는 데비안 계열 리눅스(Debian, Ubuntu)에서 시스템에 설치할 수 있는 deb 패키지들을 가지고 있는 서버이며, 이 서버에 빠르게 접근할 수 있도록 서버를 통째로 복제해둔 로컬 서버입니다.

초기 기본 설정된 우분투 패키지 미러서버는 상당히 느림
- $ sudo apt update 등 패키지 다운로드시 불편
- 패키지 다운로드 속도를 향상시키기 위해 미러서버 변경
초기 기본 설정된 우분투 패키지 미러서버(EC2 인스턴스에 따라 다를 수 있음):
- http://kr.archive.ubuntu.com/ubuntu/
- http://ap-southeast-2.ec2.archive.ubuntu.com/ubuntu/
- http://ap-northeast-2.ec2.archive.ubuntu.com/ubuntu/
변경 가능한 우분투의 미러서버를 검색할 수 있는 사이트
- cdmirrors: Ubuntu 설치용 CD 이미지 배포 저장소
  - https://launchpad.net/ubuntu/+cdmirrors
- archivemirrors: Ubuntu 패키지 저장소
  - https://launchpad.net/ubuntu/+archivemirrors
국내 변경 가능한 우분투 미러서버:
- http://ftp.kaist.ac.kr/ubuntu/
- http://mirror.kakao.com/ubuntu/

# 문자열 변경 명령어
:%s/원본 문장/변경 문장

# 카이스트 미러서버 변경
$ sudo vi /etc/apt/sources.list
:%s/kr.archive.ubuntu.com/ftp.kaist.ac.kr/
:%s/ap-southeast-2.ec2.archive.ubuntu.com/ftp.kaist.ac.kr/
:%s/ap-northeast-2.ec2.archive.ubuntu.com/ftp.kaist.ac.kr/

# 카카오 미러서버 변경
$ sudo vi /etc/apt/sources.list
$ :%s/kr.archive.ubuntu.com/mirror.kakao.com/
$ :%s/ap-southeast-2.ec2.archive.ubuntu.com/mirror.kakao.com/
$ :%s/ap-northeast-2.ec2.archive.ubuntu.com/mirror.kakao.com/

📌 패키지 업데이트

PPA(Personal Package Archive): 개인 패키지 저장소 = 비공식 패키지 저장소
- Launchpad에서 제공하는 우분투 공식 패키지 저장소에는 없는 서드 파티 소프트웨어를 위한 개인용 소프트웨어 패키지 저장소

$ sudo apt update
$ sudo apt upgrade
$ sudo add-apt-repository --remove ppa:certbot/certbot

📌 가상 메모리 할당

Swap 메모리는 하드디스크의 일부를 RAM처럼 사용하도록 만들어진 메모리
HDD 장치를 사용하는 것이기 때문에 읽고 쓰는 속도가 급격히 느려짐
일반적으로 RAM 용량의 1배 ~ 2배를 Swap 메모리로 권장

[AWS EC2 Swap 메모리 할당방법] https://repost.aws/knowledge-center/ec2-memory-swap-file [AWS EC2 Swap 메모리 권장크기] https://help.ubuntu.com/community/SwapFaq#How_much_swap_do_I_need.3F

📖 메모리 확인

# 메모리 사용량, 여유량, 캐시 크기
$ free
$ free -b # 메모리 크기를 바이트 단위로 출력
$ free -k # 메모리 크기를 키비바이트 단위로 출력 
$ free -m # 메모리 크기를 메비바이트 단위로 출력
$ free -g # 메모리 크기를 기비바이트 단위로 출력
$ free -h # 메모리 크기를 사람이 읽기 쉬운 단위로 출력

📖 Swap 메모리 비활성화

# 활성화 중인 Swap 메모리가 있다면 비활성화
$ sudo free -m
$ sudo swapon -s
$ sudo swapoff -a
$ sudo swapoff -v /swapfile

📖 Swap 메모리 할당 방법 1

# In this example dd command, the swapfile is 2 GB (64 MB x 32):
$ sudo dd if=/dev/zero of=/swapfile bs=64M count=32
$ sudo chmod 600 /swapfile        # 권한 수정
$ sudo mkswap /swapfile           # swapfile 생성
$ sudo swapon /swapfile           # swapfile 활성화
$ sudo nano /etc/fstab            # 파일 편집
/swapfile swap swap defaults 0 0  # 내용 추가 (권장)
/swapfile none swap sw 0 0        # 내용 추가 (옵션)

# [파일시스템장치] [마운트포인트] [파일시스템 종류] [옵션] [dump설정] [파일점검옵션]
    /swapfile        swap          swap     defaults    0          0
    /swapfile        none          swap        sw       0          0

# linux/ubuntu dd command

# In this example dd command, the swapfile is 1 GB (64 MB x 16):
# In this example dd command, the swapfile is 2 GB (64 MB x 32):
# In this example dd command, the swapfile is 4 GB (128 MB x 32):
# In this example dd command, the swapfile is 8 GB (128 MB x 64):
$ sudo dd if=/dev/zero of=/swapfile bs=64M count=16
$ sudo dd if=/dev/zero of=/swapfile bs=64M count=32
$ sudo dd if=/dev/zero of=/swapfile bs=128M count=32
$ sudo dd if=/dev/zero of=/swapfile bs=128M count=64

# if [File] = 지정한 파일을 입력대상으로 설정
# of [File] = 지정한 파일을 출력대상으로 설정
# bs [Bytes] = 한 번에 읽고 쓸 최대 바이트 크기 지정
# count [Number Blocks] = 지정한 블록 수 만큼 복사
# /dev/zero 내용을 읽고, /swapfile 파일에 쓰기, 64M 크기로 16번

📖 Swap 메모리 할당 방법 2

fallocate를 사용하여 빈 파일을 생성하는 것은, dd를 사용하는 것보다 더 간단하고 빠름
큰 파일을 생성할 때 성능 상 이점이 있으나, 파일 시스템이 fallocate를 지원해야 하며, 지원하지 않는 파일 시스템에서는 사용할 수 없음

$ sudo fallocate -l 8G /swapfile  # Swap 메모리 할당 8GB
$ sudo chmod 600 /swapfile        # 권한 수정
$ sudo mkswap /swapfile           # swapfile 생성
$ sudo swapon /swapfile           # swapfile 활성화
$ sudo nano /etc/fstab            # 파일 편집
/swapfile swap swap defaults 0 0  # 내용 추가 (옵션)
/swapfile none swap sw 0 0        # 내용 추가 (권장)

# [파일시스템장치] [마운트포인트] [파일시스템 종류] [옵션] [dump설정] [파일점검옵션]
    /swapfile        swap          swap     defaults    0          0
    /swapfile        none          swap        sw       0          0

마운트 포인트 필드: 일반적으로 swap 파일의 경우 마운트 포인트로 none을 사용합니다. swap 파일 또는 파티션은 실제 파일 시스템 마운트 포인트에 위치하지 않습니다.
옵션 필드: defaults 또는 sw와 같은 옵션들이 있으며, swap에 관련된 옵션을 지정합니다.
- defaults: 파일 시스템에 대한 기본 마운트 옵션을 의미합니다. swap의 경우, 특별한 마운트 옵션이 필요 없기 때문에 이 옵션은 실질적으로 무시될 수 있습니다.
- sw: swap 파일이나 파티션을 활성화하기 위해 사용되는 옵션이며, swapon 명령어에 해당하는 옵션입니다. 일반적으로 swap 항목에서는 sw 옵션이 더 명확한 의미를 가집니다.

결론 - 일반적으로 사용되는 방법 /swapfile none swap sw 0 0이 /swapfile swap swap defaults 0 0보다 더 명확하고 표준적인 표현으로, swapfile 이나 파티션을 /etc/fstab에 추가할 때 일반적으로 사용됩니다. none을 사용하는 것이 마운트 포인트가 필요 없는 swap에 더 적합하며, sw 옵션은 swap 활성화를 명시적으로 나타냅니다.

📖 Swap 메모리 삭제

# swapfile 삭제
$ sudo free -m
$ sudo swapon -s
$ sudo swapoff -a                 # 모두 비활성화
$ sudo swapoff -v /swapfile       # swapfile 비활성화
$ sudo nano /etc/fstab
/swapfile swap swap defaults 0 0  # 내용 삭제
$ sudo rm /swapfile               # swapfile 삭제

📌 킬로바이트(KB)와 키비바이트(KiB)

SI 접두어: 국제단위계(International System of Units; 약칭 SI)에서 각 단위의 양의 크기를 쉽게 나타내기 위해 각 단위의 앞에 붙여 쓰는 접두어

킬로바이트(KiloByte): 킬로 바이트, SI 접두어
```
1 KB = 10³ bytes = 1000 bytes
```
키비바이트(KibiByte): 킬로 이진 바이트, Kilo Binary Byte의 준말
```
1 KiB = 2¹⁰ bytes = 1024 bytes
```
https://80000coding.oopy.io/c51ad838-cde0-4f1e-b93b-7dd8d60ef6a2

[SpringBoot] 스프링부트 스케줄러 @Scheduled, @EnableSchedule

Sat, 15 Jul 2023 12:50:24 GMT

📌 @EnableScheduling

Main Application Class에 @EnableScheduling 추가
org.springframework.boot:spring-boot-starter 기본 내장

package com.project.projectname;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class ProjectNameApplication {

    public static void main(String[] args) {
        SpringApplication.run(rojectNameApplication.class, args);
    }

}

@Scheduled 사용 규칙
- Class에 @Component
- Method에 @Scheduled
  - Method는 void 타입
  - Method는 매개변수 사용불가

📌 @Scheduled

@Scheduled 병렬 사용 방법
- Class에는 @EnableAsync 추가
- Method에는 @Async 추가

📖 fixedDelay & fixedDelayString

이전 작업이 완료될 때까지 대기
메서드 종료시간 기준, milliseconds 간격으로 실행
하나의 인스턴스만 항상 실행되도록 해야 할 상황에서 유용
milliseconds 타입에 따라 정수이면 fixedDelay 문자열이면 fixedDelayString

@Scheduled(fixedDelay = 1000)
public void scheduledFixedDelayTest() throws InterruptedException {
    log.info("Fixed Delay Test: {}", System.currentTimeMillis() / 1000);
    Thread.sleep(5000);
}

// 문자열 milliseconds를 사용할 때
@Scheduled(fixedDelayString = "${fixedDelay.in.milliseconds}")
public void scheduledFixedDelayStringTest() throws InterruptedException {
    log.info("Fixed Delay String Test: {}", System.currentTimeMillis() / 1000);
    Thread.sleep(5000);
}

📖 fixedRate & fixedRateString

이전 작업이 완료될 때까지 대기
메서드 시작시간 기준, milliseconds 간격으로 실행
모든 실행이 독립적인 경우에 유용
milliseconds 타입에 따라 정수이면 fixedRate 문자열이면 fixedRateString

@Scheduled(fixedRate = 1000)
public void scheduledFixedRateTest() throws InterruptedException {
    log.info("Fixed Rate Test: {}", System.currentTimeMillis() / 1000);
    Thread.sleep(5000);
}

// 문자열 milliseconds를 사용할 때
@Scheduled(fixedRateString = "${fixedRate.in.milliseconds}")
public void scheduledFixedRateStringTest() throws InterruptedException {
    log.info("Fixed Rate String Test: {}", System.currentTimeMillis() / 1000);
    Thread.sleep(5000);
}

📖 initialDelay & initialDelayString

초기 지연 시간으로 최초 실행시에만 적용되는 지연 시간
fixedDelay 혹은 fixedRate 등의 고정 시간값과 함께 사용
initialDelay 시간 이후 최초 실행, 이후 fixedDelay 시간마다 실행
milliseconds 타입에 따라 정수이면 initialDelay 문자열이면 initialDelayString

// 1초 대기 후 메서드 종료시간 기준으로 5초마다 반복
@Scheduled(fixedDelay = 5000, initialDelay = 1000)
public void scheduledFixedDelayWithInitialDelayTest() {
    long now = System.currentTimeMillis() / 1000;
    log.info("Initial Delay with Fixed Delay Test: {}", now);
}

// 1초 대기 후 메서드 시작시간 기준으로 5초마다 반복
@Scheduled(fixedRate = 5000, initialDelayString = "1000")
public void scheduledFixedRateWithInitialDelayTest() {
    long now = System.currentTimeMillis() / 1000;
    log.info("Initial Delay with Fixed Rate Test: {}", now);
}

📖 Cron & Zone

Cron 표현식을 통해 매 특정 시점마다 실행
- Cron: "* * * * * *"
- 초(0-59) 분(0-59) 시간(0-23) 일(1-31) 월(1-12) 요일(0-7)
Zone = "Asia/Seoul"
- Default는 Local 시간대 사용

@Scheduled(cron = "0 15 10 15 * ?") // 매월 15일 오전 10시 15분 실행
// @Scheduled(cron = "0 15 10 15 11 ?") // 11월 15일 오전 10시 15분 실행
// @Scheduled(cron = "${cron.expression}")
public void scheduledCronExpressionTest() {
    long now = System.currentTimeMillis() / 1000;
    log.info("Scheduled with Cron Expression Test: {}", now);
}

// 유럽/파리 시간 기준 매월 15일 오전 10시 15분 실행
@Scheduled(cron = "0 15 10 15 * ?", zone = "Europe/Paris")
public void scheduledCronExpressionWithZoneTest() {
    long now = System.currentTimeMillis() / 1000;
    log.info("Scheduled with Cron Expression and Zone Test: {}", now);
}

📌 Summary

📋 fixedDelay & fixedDelayString

이전 작업이 완료될 때까지 대기
메서드 종료시간 기준, milliseconds 간격으로 실행
하나의 인스턴스만 항상 실행되도록 해야 할 상황에서 유용
milliseconds 타입에 따라 정수이면 fixedDelay 문자열이면 fixedDelayString

📋 fixedRate & fixedRateString

이전 작업이 완료될 때까지 대기
메서드 시작시간 기준, milliseconds 간격으로 실행
모든 실행이 독립적인 경우에 유용
milliseconds 타입에 따라 정수이면 fixedRate 문자열이면 fixedRateString

📋 initialDelay & initialDelayString

초기 지연 시간으로 최초 실행시에만 적용되는 지연 시간
fixedDelay 혹은 fixedRate 등의 고정 시간값과 함께 사용
initialDelay 시간 이후 최초 실행, 이후 fixedDelay 시간마다 실행
milliseconds 타입에 따라 정수이면 initialDelay 문자열이면 initialDelayString

📋 Cron & Zone

Cron 표현식을 통해 매 특정 시점마다 실행
- Cron: "* * * * * *"
- 초(0-59) 분(0-59) 시간(0-23) 일(1-31) 월(1-12) 요일(0-7)
Zone = "Asia/Seoul"
- Default는 Local 시간대 사용

📌 Test

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component // Class에는 @Component 추가
@EnableAsync // Class에는 @EnableAsync 추가
public class ScheduleTest {

    /**
     * 이전 작업이 완료될 때까지 대기
     * 메서드 종료시간 기준, `milliseconds` 간격으로 실행
     * 하나의 인스턴스만 항상 실행되도록 해야 할 상황에서 유용
     */
    @Scheduled(fixedDelay = 1000)
    public void scheduledFixedDelayTest() throws InterruptedException {
        log.info("Fixed Delay Test: {}", System.currentTimeMillis() / 1000);
        Thread.sleep(5000);
    }

    // 문자열 milliseconds를 사용할 때
    @Scheduled(fixedDelayString = "${fixedDelay.in.milliseconds}")
    public void scheduledFixedDelayStringTest() throws InterruptedException {
        log.info("Fixed Delay String Test: {}", System.currentTimeMillis() / 1000);
        Thread.sleep(5000);
    }


    /**
     * 이전 작업이 완료될 때까지 대기
     * 메서드 시작시간 기준, `milliseconds` 간격으로 실행
     * 모든 실행이 독립적인 경우에 유용
     */
    @Async // Method에는 @Async 추가
    @Scheduled(fixedRate = 1000)
    public void scheduledFixedRateTest() throws InterruptedException {
        log.info("Fixed Rate Test: {}", System.currentTimeMillis() / 1000);
        Thread.sleep(5000);
    }

    // 문자열 milliseconds를 사용할 때
    @Async // Method에는 @Async 추가
    @Scheduled(fixedRateString = "${fixedRate.in.milliseconds}")
    public void scheduledFixedRateStringTest() throws InterruptedException {
        log.info("Fixed Rate String Test: {}", System.currentTimeMillis() / 1000);
        Thread.sleep(5000);
    }


    /**
     * 초기 지연 시간으로 최초 실행시에만 적용되는 지연 시간
     * `fixedDelay` 혹은 `fixedRate` 등의 고정 시간값과 함께 사용
     * `initialDelay` 시간 이후 최초 실행, 이후 `fixedDelay` 시간마다 실행
     */
    // 1초 대기 후 메서드 종료시간 기준으로 5초마다 반복
    @Scheduled(fixedDelay = 5000, initialDelay = 1000)
    public void scheduledFixedDelayWithInitialDelayTest() {
        long now = System.currentTimeMillis() / 1000;
        log.info("Initial Delay with Fixed Delay Test: {}", now);
    }

    // 1초 대기 후 메서드 시작시간 기준으로 5초마다 반복
    @Scheduled(fixedRate = 5000, initialDelayString = "1000")
    public void scheduledFixedRateWithInitialDelayTest() {
        long now = System.currentTimeMillis() / 1000;
        log.info("Initial Delay with Fixed Rate Test: {}", now);
    }


    /**
     * `Cron` 표현식을 통해 매 특정 시점마다 실행
     * * `Cron`: `"* * * * * *"`
     * * 초(0-59) 분(0-59) 시간(0-23) 일(1-31) 월(1-12) 요일(0-7)
     * `Zone` = `"Asia/Seoul"`
     * * `Default`는 `Local` 시간대 사용
     */
    @Scheduled(cron = "0 15 10 15 * ?") // 매월 15일 오전 10시 15분 실행
    // @Scheduled(cron = "0 15 10 15 11 ?") // 11월 15일 오전 10시 15분 실행
    // @Scheduled(cron = "${cron.expression}")
    public void scheduledCronExpressionTest() {
        long now = System.currentTimeMillis() / 1000;
        log.info("Scheduled with Cron Expression Test: {}", now);
    }

    // 유럽/파리 시간 기준 매월 15일 오전 10시 15분 실행
    @Scheduled(cron = "0 15 10 15 * ?", zone = "Europe/Paris")
    public void scheduledCronExpressionWithZoneTest() {
        long now = System.currentTimeMillis() / 1000;
        log.info("Scheduled with Cron Expression and Zone Test: {}", now);
    }

}

📌 Reference

https://data-make.tistory.com/699

SihoonCho's.log

TypeScript 프로젝트 구조 & 파일 네이밍 컨벤션 (실무 기준 정리)

1. 📌 TypeScript 구조의 핵심: 모듈 시스템

기본 개념

Java vs TypeScript

2. 📦 실무에서 가장 많이 쓰는 디렉토리 구조

기본 구조

구조 특징

3. 🗂️ 파일 네이밍 컨벤션 (domain.role)

규칙

예시

장점

✔ 역할이 명확함

✔ 정렬이 직관적

✔ 파일명 충돌 방지

용어

4. 🔤 코드 레벨 네이밍 규칙

클래스

함수 / 변수

상수

타입 / 인터페이스

파일 vs 클래스

🚀 정리

📎 참고 자료

[SpringBoot] 2024 JWT ① - 기본 설정

※ 읽기에 앞서

📌 JWT (JSON Web Token)

JWT (JSON Web Token)

📖 JWT 구조

JWT 구조

📖 JWT 장단점

장점

단점

📌 JWT 기본설정

JWT 기본설정

📖 build.gradle

JJWT (Java JWT)

📖 application.properties

application.properties

[SpringBoot] 2024 게시판 만들기 Q&A ⑥ - JPQL, 네이티브 쿼리

※ 읽기에 앞서

📌 JPQL

Raw JPA vs Spring Data JPA

📖 JPQL 개념

특징

작동 원리

JPQL vs Native SQL

📖 JPQL 예제코드

✅ 패키지 구조

✅ PostRepository

✅ PostService

✅ 다양한 응용 예시

📌 Native Query

📖 Native Query 개념

특징

작동 원리

사용 목적

📖 Native Query 예제코드

✅ 패키지 구조

✅ PostRepository

✅ PostService

✅ 다양한 응용 예시

📌 JPA vs JPQL vs Native Query

📖 JPA

📖 JPQL

📖 Native Query

차이점 정리

[SpringBoot] 2024 게시판 만들기 Q&A ⑤ - Spring Data JPA

※ 읽기에 앞서

📌 JPA

📖 JPA 개념

ORM(Object-Relational Mapping)

JPA(Java Persistence API)

📌 Spring Data JPA

📖 Spring Data JPA 개념

📖 Spring Data JPA 동작 원리

Spring Data JPA 동작 과정

📌 결론

📖 JPA 장단점

JPA 장점

✅ `PostRepository`

✅ `PostService`

✅ `다양한 응용 예시`

✅ `PostService`

✅ `다양한 응용 예시`