얼렁뚱땅 개발 블로그

Java문법 startsWith

h_jinnny — Mon, 29 Dec 2025 20:57:41 +0900

1️⃣ startsWith()란?

startsWith()는 문자열이 특정 문자열로 시작하는지를 확인하는 메서드입니다.

반환 타입: boolean
소속 클래스: java.lang.String

2️⃣ 기본 문법

String str = "HelloWorld"; boolean result = str.startsWith("Hello");

✔ result → true

3️⃣ 예제별 설명

✅ 문자열이 특정 값으로 시작하는지 확인

String url = "/api/users"; 
if (url.startsWith("/api")) { 
	System.out.println("API 요청입니다."); 
}

➡️ REST API 라우팅, 필터, 인터셉터에서 자주 사용

✅ 대소문자 구분

String text = "Java"; 
System.out.println(text.startsWith("java")); // false 
System.out.println(text.startsWith("Java")); // true

⚠️ startsWith()는 대소문자를 구분합니다.

4️⃣ 특정 위치부터 시작하는지 확인 (오버로딩)

boolean startsWith(String prefix, int toffset)

예제

String str = "HelloWorld"; 
System.out.println(str.startsWith("World", 5)); // true

✔ 인덱스 5부터 "World"가 시작하는지 확인

5️⃣ 실무에서 많이 쓰는 패턴

권한 / 토큰 검사

String authHeader = "Bearer eyJhbGciOi..."; 
if (authHeader.startsWith("Bearer ")) { 
	String token = authHeader.substring(7); 
}

➡️ JWT 인증 처리에서 매우 흔함
(지금까지 하신 Spring + JWT 프로젝트랑 딱 맞는 예제예요)

파일 확장자 체크

String fileName = "image.png"; 
if (fileName.startsWith("image")) { 
	// 이미지 관련 처리 
}

6️⃣ startsWith() vs contains()

메서드의미

startsWith()	처음부터 일치
contains()	문자열 어디든 포함

"HelloWorld".startsWith("World"); // false 
"HelloWorld".contains("World"); // true

7️⃣ 주의사항 ⚠️

String str = null; str.startsWith("Hi"); // ❌ NullPointerException

✔ null 체크 필수

if (str != null && str.startsWith("Hi")) { ... }

8️⃣ 한 줄 요약

startsWith()는 문자열이 특정 접두사(prefix)로 시작하는지 검사하는 메서드이며,
API 경로 처리, 인증 헤더 검사, 문자열 분기 처리에 매우 자주 사용됩니다.

Kafka의 분산처리

h_jinnny — Sun, 24 Nov 2024 18:08:38 +0900

성능 개선: Kafka 기반 채팅 서비스 아키텍처 최적화 사례

1. 문제 상황

기존의 채팅 서비스에서는 모든 채팅방의 메시지가 하나의 Kafka 토픽과 하나의 파티션에서 처리되었습니다. 초기 구현에서는 단일 채널로도 정상적으로 동작했지만, 채팅방 수가 증가하면서 다음과 같은 문제가 발생했습니다:

처리 병목현상: 단일 파티션으로 인해 모든 메시지가 순차적으로 처리되어 동시 처리 능력이 제한되었습니다.
시스템 리소스 불균형: 메모리 및 CPU 사용이 특정 시점에 집중되면서 성능 저하와 응답 시간 증가가 발생했습니다.
스케일링 어려움: 새로운 채팅방이 추가될수록 기존 토픽의 부담이 커져 확장성이 떨어졌습니다.

2. 기존 구조와 한계

처리 방식: 하나의 토픽, 하나의 파티션에서 모든 채팅방을 처리.
동시성 제한: 메시지가 단일 파티션에 집중되면서 동시 처리의 이점이 사라짐.
메타데이터 관리: 방대한 메시지를 처리하는 과정에서 메타데이터 갱신 시간도 증가.

3. 개선된 구조

새로운 아키텍처는 다음과 같이 설계되었습니다:

구분기존 구조개선된 구조

구분	기존 구조	개선된 구조
구분	기존 구조	개선된 구조	처리 방식	모든 채팅방을 하나의 토픽, 하나의 파티션에서 처리	채팅방 10개당 1개의 토픽 사용. 각 토픽은 10개의 파티션으로 구성, 채팅방별로 파티션 할당
토픽 번호	N/A	roomId / 10 + 1 (예: chatTopic1, chatTopic2, ...)
파티션 번호	N/A	roomId % 10 (예: 0, 1, 2, ...)
미리 생성	N/A	기존 토픽의 5번째 파티션 사용 시 다음 토픽 미리 생성
예시	N/A	roomId가 13인 경우 → 토픽: chatTopic2, 파티션: 3

4. 성능 개선 및 기대 효과

병렬 처리 능력 향상
- 여러 채팅방의 메시지가 독립적으로 처리되어 동시성 향상.
- 결과적으로 메시지 송수신 지연 시간이 감소.
메모리 및 CPU 자원 최적화
- 파티션과 토픽이 분산되어 리소스 사용량이 균형 있게 조정.
- 서비스 안정성이 크게 향상됨.
스케일링 용이성
- 새로운 채팅방이 추가될 때, 기존 토픽과 파티션 구조를 확장하여 유연하게 대응 가능.
메시지 지연 시간 감소
- 각 파티션이 독립적으로 작동함으로써 메시지 전송과 소비 간의 지연 시간이 줄어듦.
메타데이터 갱신 시간 절약
- 다음 토픽을 미리 생성하여 갱신 작업을 최소화.
- 시스템의 전체 응답성이 향상됨.

kafka

h_jinnny — Sun, 4 Aug 2024 22:40:14 +0900

Kafka란?

Apache Kafka는 고성능, 내구성, 그리고 확장 가능한 분산 스트리밍 플랫폼이다. Kafka는 데이터 파이프라인을 구축하고 실시간 데이터 스트리밍을 처리하는 데 매우 적합하다.

프로듀서(Producer): 메시지를 생성하여 Kafka 토픽으로 전송하는 역할을 한다.
컨슈머(Consumer): Kafka 토픽에서 메시지를 읽어오는 역할을 한다.
브로커(Broker): Kafka 서버로, 토픽과 메시지를 저장하고 관리한다.
토픽(Topic): 메시지가 게시되는 논리적 채널이다.

Kafka는 다음과 같은 경우에 많이 사용된다:

실시간 데이터 처리: 실시간 로그, 이벤트 스트리밍 처리
데이터 파이프라인: 서로 다른 시스템 간의 데이터 전송
분산 시스템: 여러 마이크로서비스 간의 메시지 교환
데이터 통합: 다양한 데이터 소스를 통합하여 분석 및 모니터링

Kafka의 주요 특징

분산 시스템: Kafka는 분산형 구조로 설계되어 있어, 여러 서버(브로커)에서 데이터를 저장하고 처리할 수 있다. 이로 인해 높은 가용성과 확장성을 제공한다.
높은 처리량: Kafka는 대규모 데이터 스트리밍을 처리할 수 있는 높은 처리량을 자랑한다. 이를 통해 초당 수백만 개의 메시지를 처리할 수 있다.
내구성: Kafka는 데이터를 복제하여 여러 브로커에 저장하므로, 서버 장애가 발생해도 데이터가 손실되지 않는다. 데이터의 내구성을 보장한다.
실시간 데이터 처리: Kafka는 실시간 데이터 처리를 지원하여, 데이터가 생성되는 즉시 소비자에게 전달할 수 있다.
확장성: Kafka는 새로운 브로커를 추가하여 수평적으로 확장할 수 있다. 이를 통해 데이터 처리 용량을 쉽게 늘릴 수 있다.
높은 가용성: Kafka 클러스터는 데이터의 복제와 자동 복구 기능을 통해 높은 가용성을 제공한다.

Kafka를 사용하는 이유

실시간 데이터 스트리밍: 실시간으로 생성되는 데이터를 처리하고 전송할 때 유용하다. 예를 들어, 로그 수집, 트랜잭션 모니터링, 사용자 활동 추적 등에 적합하다.
대량의 데이터 처리: 대규모 데이터 처리가 필요한 시스템에서 Kafka는 높은 처리량과 낮은 지연 시간을 제공하여, 대량의 데이터를 효율적으로 관리할 수 있다.
데이터 파이프라인 구축: 다양한 데이터 소스에서 데이터를 수집하고 처리하여 다른 시스템으로 전달하는 데이터 파이프라인을 구축할 때 사용된다. 예를 들어, 데이터 웨어하우스나 분석 시스템으로의 데이터 전송에 활용된다.
내구성 및 안정성: 데이터가 손실되지 않고 안정적으로 저장되며, 브로커 간의 데이터 복제를 통해 장애 발생 시에도 데이터가 보호된다.
데이터 통합: 다양한 시스템과 애플리케이션 간의 데이터 통합을 지원한다. Kafka는 다양한 데이터 소스와 소비자 간의 데이터 흐름을 중재할 수 있다.
확장성: 시스템이 성장함에 따라 처리 용량을 쉽게 확장할 수 있다. Kafka 클러스터에 브로커를 추가하여 수평적으로 확장할 수 있다.

Kafka의 사용 사례

로그 및 이벤트 수집: 서버 로그, 애플리케이션 로그, 사용자 이벤트 등을 실시간으로 수집하고 분석하는 데 사용된다.
모니터링 및 경고: 시스템 성능과 상태를 모니터링하고 이상 징후를 감지하여 경고를 생성하는 데 유용하다.
데이터 파이프라인: 데이터 웨어하우스, 데이터 레이크 등으로 데이터를 전송하는 파이프라인을 구축할 때 사용된다.
실시간 분석: 실시간으로 데이터 분석을 수행하여 인사이트를 얻는 데 활용된다.

Docker로 Kafka 설정

Docker를 사용하면 Kafka를 쉽게 설정하고 실행할 수 있다. Docker Compose 파일을 작성하여 Kafka와 Zookeeper를 설정한다.

이 파일을 통해 Zookeeper와 Kafka 브로커를 Docker 컨테이너로 실행할 수 있다.

그렇다면 Zookeeper와 브로커는 뭘까??

Kafka의 주요 구성 요소

1. Zookeeper

Zookeeper는 분산 애플리케이션을 위한 중앙 집중형 서비스로, 구성 정보, 네이밍, 동기화, 그룹 서비스를 제공한다. Kafka는 Zookeeper를 사용하여 브로커와 클러스터 메타데이터를 관리하고, 브로커 간의 협업을 돕는다. Zookeeper는 클러스터의 상태를 유지하고, 새로운 브로커가 추가되거나 실패한 브로커를 감지하여 이를 다른 브로커에 통지하는 역할을 한다.

2. 브로커(Broker)

브로커는 Kafka 서버를 의미하며, 메시지를 저장하고 관리하는 역할을 한다. 브로커는 여러 개의 토픽을 호스팅하며, 각각의 토픽은 여러 개의 파티션으로 나뉘어진다. 브로커는 각 파티션의 리더와 팔로워를 관리하며, 메시지의 복제와 분산 처리를 수행한다. 클러스터 내의 브로커들은 서로 협력하여 고가용성과 내구성을 제공한다.

Spring Boot에서의 kafka는?

Kafka 프로듀서 작성

Kafka 프로듀서는 메시지를 생성하여 Kafka 토픽으로 전송하는 역할을 한다. Spring Boot에서 Kafka 프로듀서를 작성하려면 KafkaTemplate을 사용하면 된다.

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class KafkaProducer {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    private static final String TOPIC = "test_topic";

    @GetMapping("/send")
    public String sendMessage(@RequestParam("message") String message) {
        kafkaTemplate.send(TOPIC, message);
        return "Message sent to Kafka topic";
    }
}

Kafka 컨슈머 작성

Kafka 컨슈머는 Kafka 토픽에서 메시지를 읽어오는 역할을 한다. Spring Boot에서 Kafka 컨슈머를 작성하려면 @KafkaListener를 사용하면 된다.

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumer {

    @KafkaListener(topics = "test_topic", groupId = "group_id")
    public void consume(String message) {
        System.out.println("Consumed message: " + message);
    }
}

클라이언트가 브라우저에서 "http://localhost:8080/send?message=HelloKafka"를 접속하면 "HelloKafka" 메시지가 Kafka 토픽에 전송된다. 컨슈머가 이 메시지를 읽어 콘솔에 출력하는 것을 확인할 수 있다.

Consumed message: HelloKafka

Hibernate Naming Strategies

h_jinnny — Wed, 26 Jun 2024 15:46:59 +0900

혼자 공부할겸 프로젝트를 진행하다가 예상치못한 오류에 막혀서 많은 시간을 소요하였다.

데이터베이스의 테이블에서 값을 전혀 불러오지 못하는 문제였다.

아무리 찾아봐도 문제를 찾지 못하다가 혹시나 하는 마음에 모든 테이블을 조회해보았고 생성한 적 없는 테이블이 만들어져있는 것을 봤다.

기존에 만든 테이블은 orderItems인데 새로 생성된 테이블은 order_items가 있었다.

분명 엔티티에서 table(name="orderItems")로 작성해서 orderItems테이블과 매핑이 되어있을 것이라고 생각했는데 order_items테이블이 새로 생기며 여기와 매핑을 하고 있던 것이다.

이는 바로 Hibernate Naming Strategies의 Physical Naming Strategy의한 것이다.

Hibernate Naming Strategies

Naming Strategies는 Hibernate가 엔티티 클래스의 필드와 데이터베이스 테이블의 컬럼을 매핑하는 방식을 정의한다. 이를 통해 코드를 간결하게 유지하고, 일관된 네이밍 규칙을 적용할 수 있다. Hibernate는 두 가지 주요 네이밍 전략을 제공한다

Physical Naming Strategy: 데이터베이스의 실제 테이블 및 컬럼 이름을 결정한다. 논리적 이름을 실제 데이터베이스에 적용할 물리적 이름으로 변환한다.
Implicit Naming Strategy: 명시적으로 지정되지 않은 테이블 및 컬럼 이름을 결정한다.

1. Physical Naming Strategy

PhysicalNamingStrategy는 Java 엔티티 필드 이름을 데이터베이스의 실제 테이블 및 컬럼 이름으로 변환하는 방법을 정의한다.

@Entity
@Table(name = "orderItems")
public class OrderItem {
    @Id
    private Long id;
    private String productName;
}

논리적 이름 지정

@Table(name = "orderItems")에 의해 논리적 테이블 이름은 orderItems로 지정됩니다.

물리적 이름 변환

PhysicalNamingStrategyStandardImpl가 논리적 이름 orderItems를 물리적 이름 order_items로 변환합니다.
즉 카멜케이스를 스네이크케이스로 바꾼다고 볼 수 있다.

2. Implicit Naming Strategy

ImplicitNamingStrategy는 명시적으로 지정되지 않은 경우 기본값으로 사용될 이름을 정의한다. 기본적으로 제공되는 구현은 다음과 같다:

ImplicitNamingStrategyLegacyJpaImpl: JPA의 기본 네이밍 규칙을 따른다.
ImplicitNamingStrategyComponentPathImpl: 필드명을 기반으로 명명한다.
ImplicitNamingStrategyJpaCompliantImpl: JPA 2.0 명명 규칙을 따른다.

@Entity
@Getter
@Setter
public class UserAccount {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String userName;
}

ImplicitNamingStrategyLegacyJpaImpl을 사용할 경우, UserAccount 엔티티는 user_account 테이블에 매핑되고, userName 필드는 user_name 컬럼에 매핑된다.

모두들 테이블명과 컬럼명에 잘 매핑했다고 생각하고 그냥 넘어가지말고 다시한번 확인해보며 시간을 줄이면 좋을거같다

[AWS] EC2와 RDS 설정 및 프로젝트 배포

h_jinnny — Wed, 12 Jun 2024 11:56:05 +0900

AWS EC2와 RDS 인스턴스를 설정하고, GitHub에서 프로젝트를 클론하여 빌드하고 배포하는 방법을 단계별로 안내하고자 한다.

또한, S3를 이용한 빌드 및 배포 방법도 소개할 것이다.

1. AWS EC2 인스턴스 설정

1.1. EC2 인스턴스 생성

AWS 콘솔에 로그인하고 EC2 대시보드로 이동한다.
인스턴스 시작 버튼을 클릭한다.
**Amazon Machine Image (AMI)**에서 원하는 OS를 선택한다. (예: Amazon Linux 2)
인스턴스 유형을 선택한다. (예: t2.micro)
인스턴스 세부 정보 구성, 스토리지 추가 및 태그 추가 단계를 기본값으로 둔다.
보안 그룹 구성 단계에서, 새로운 보안 그룹을 생성하고 HTTP(80) 및 SSH(22) 포트를 허용한다.
검토 및 시작 버튼을 클릭한 후 시작 버튼을 클릭한다.
새로운 키 페어를 생성하거나 기존 키 페어를 선택하여 다운로드한다.

1.2. EC2 인스턴스에 접속

터미널이나 CMD를 열고, 인스턴스 생성 시 다운로드한 키 페어를 사용하여 SSH로 접속한다:

chmod 400 your-key-pair.pem 
ssh -i "your-key-pair.pem" ec2-user@your-ec2-public-ip

1.3. 시스템 업데이트 및 필수 패키지 설치

EC2 인스턴스에 접속한 후, 시스템을 업데이트하고 필요한 패키지를 설치한다:

yum list installed
sudo yum update

sudo yum install git
git config --global user.name "(git 이름)"
git config --global user.email "(git 이메일)"
sudo yum install -y java-21-amazon-corretto-devel

1.4. AWS CLI 설치 및 aws configure 설정

1.4.1. AWS CLI(AWS Command Line Interface) 설치

ec2는 리눅스 기반이므로 아래의 명령어를 진행하여 설치한다

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

1.4.2.aws configure 설정

aws configure

AWS Access Key ID [None]: 해당 사용자의 accessKey의 Id를 입력
AWS Secret Access Key [None]: 해당 사용자의 Secret access key를 입력
Default region name [None]: ap-northeast-2
Default output format [None]: json

2. AWS RDS 인스턴스 설정

2.1. RDS 인스턴스 생성

AWS 콘솔에 로그인하고 RDS 대시보드로 이동한다.
데이터베이스 생성 버튼을 클릭한다.
표준 생성을 선택한다.
데이터베이스 엔진으로 MySQL을 선택한다.
템플릿을 선택한다. (예: 프리 티어) ~~다른거 쓰면 과금.....~~
데이터베이스 인스턴스 식별자, 마스터 사용자 이름 및 비밀번호를 설정한다.
DB 인스턴스 크기 및 스토리지 설정을 완료한다.
연결 설정에서 기존 VPC를 선택하고, 퍼블릭 액세스를 허용한다.
보안 그룹을 설정하여 EC2 인스턴스에서 MySQL 포트(3306)에 접근할 수 있도록 허용한다.
데이터베이스 생성 버튼을 클릭하여 RDS 인스턴스를 생성한다.

2.2. RDS 보안 그룹 설정

EC2 대시보드로 이동하여 보안 그룹을 클릭한다.
RDS 인스턴스와 연결된 보안 그룹을 선택한다.
인바운드 규칙 편집을 클릭하여, 규칙 추가 버튼을 누른다.
유형: MySQL/Aurora, 프로토콜: TCP, 포트 범위: 3306, 소스: 내 IP 또는 EC2 인스턴스에서 MySQL 포트(3306)에 접근할 수 있도록 VPC의 IPv4 CIDR을 등록해준다
저장 버튼을 클릭하여 변경 사항을 저장한다.

3. 프로젝트 설정 및 배포

3.1. 로컬 컴퓨터에서 S3로 빌드 및 배포

3.1.1. Git 리포지토리 클론 및 빌드

로컬 컴퓨터에서 GitHub 프로젝트를 클론하고 빌드한다

git clone https://github.com/your-username/your-repository.git
cd your-repository
./gradlew build

빌드가 완료되면, build/libs 디렉토리에 JAR 파일이 생성된다.

3.1.2. S3 버킷 생성 및 JAR 파일 업로드

1. S3 버킷 생성:

aws s3 mb s3://your-unique-bucket-name

2. JAR 파일 업로드

aws s3 cp ./build/libs/your-application.jar s3://your-unique-bucket-name

3.1.3. EC2에서 JAR 파일 다운로드 및 실행

EC2 인스턴스에서 S3로부터 JAR 파일을 다운로드하고 실행한다

aws s3 cp s3://your-unique-bucket-name/your-application.jar .
java -jar your-application.jar

3.2. EC2에서 바로 클론 및 빌드

3.2.1. Git 리포지토리 클론 및 빌드

EC2 인스턴스에서 GitHub 프로젝트를 클론하고 빌드한다

git clone https://github.com/your-username/your-repository.git
cd your-repository
./gradlew build

3.2.2. 애플리케이션 실행

빌드가 완료되면, build/libs 디렉토리에 JAR 파일이 생성된다. 이 파일을 실행한다

java -jar build/libs/your-application.jar

4. application.yml 설정

EC2 인스턴스에서 application.yml 파일을 설정하여 RDS에 연결한다

(뒤늦게 작성되어있지만 프로젝트를 클론하고 빌드하기 전에 미리 다 설정을 해놔야 된다!!!)

spring:
  datasource:
    url: jdbc:mysql://your-rds-endpoint:3306/your-database-name
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5Dialect

your-rds-endpoint, your-database-name, your-rds-username, your-rds-password를 실제 RDS 인스턴스의 정보로 교체한다.

위는 username과, password를 환경변수로 지정하였다.(보안을 위해서 환경변수로 지정하는 것이 바람직함)

환경변수를 로컬이나 ec2 인스턴스에서 사용하기 위해서는 해당하는 이름으로 값을 지정해줘야한다.

//vi 편집기를 통해 zsh파일을 열어준다
vi ~/.zshrc

//맨 아래에
export USERNAME=DB 유저 이름
export PASSWORD=DB 유저 비밀번호

AWS EC2와 RDS를 설정하고, GitHub에서 프로젝트를 클론하여 배포하는 방법을 정리하였음.

ec2에서 바로 클론해서 빌드 하는 방식이랑 로컬에서 클론하고 빌드한 후 s3에 업로드한 후 ec2에서 다운받아서 빌드하고 배포하는 과정 두가지를 나누어 정리했음!!

application.yml은 클론하고 빌드하기 전에 미리 작성해두자!!

* 자바스크립트 파일에 XMLHttpRequest를 열 때 url을 작성해야되는데 인스턴스를 중지시켰다가 다시 실행시키면 공개ip가 변경되므로 꼭 자바스크립트에서도 변경을 해주고 위의 과정을 실행시키자!!

관계 매핑 전략(@OneToMany, @ManyToOne, @OneToOne, @ManyToMany), 상속 매핑 전략 (SINGLE_TABLE, JOINED, TABLE_PER_CLASS)

h_jinnny — Thu, 30 May 2024 09:38:29 +0900

Java Persistence API (JPA)는 객체 관계 매핑(ORM) 기술을 통해 객체 지향 프로그래밍 언어의 객체를 관계형 데이터베이스의 테이블에 매핑한다. JPA에서는 다양한 엔티티 간의 관계를 정의할 수 있다. 본 글에서는 JPA에서의 @OneToMany, @ManyToOne, @OneToOne, @ManyToMany에 대해 설명하고, 각각의 관계에서 데이터를 저장, 수정, 삭제하는 예시를 다룰 것이다. 또한 JPA의 상속 매핑 전략에 대해서도 자세히 살펴보자.

엔티티 간의 관계

@OneToMany와 @ManyToOne

@OneToMany와 @ManyToOne 관계는 가장 흔히 사용되는 관계 중 하나로, 하나의 엔티티가 여러 엔티티와 관계를 맺는 경우이다.

예시: 국가와 도시의 관계

Country: 여러 City를 가질 수 있다.
City: 하나의 Country에 속할 수 있다.

@Entity
public class Country {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "country", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<City> cities = new ArrayList<>();

    // Getter, Setter, Constructor
}

@Entity
public class City {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToOne
    @JoinColumn(name = "country_id")
    private Country country;

    // Getter, Setter, Constructor
}

데이터 저장, 수정, 삭제 예시

public void saveCountryAndCities(EntityManager em) {
    em.getTransaction().begin();

    Country country = new Country();
    country.setName("USA");

    City city1 = new City();
    city1.setName("New York");
    city1.setCountry(country);

    City city2 = new City();
    city2.setName("Los Angeles");
    city2.setCountry(country);

    country.getCities().add(city1);
    country.getCities().add(city2);

    em.persist(country);
    em.getTransaction().commit();
}

public void updateCity(EntityManager em, Long cityId) {
    em.getTransaction().begin();
    City city = em.find(City.class, cityId);
    if (city != null) {
        city.setName("San Francisco");
    }
    em.getTransaction().commit();
}

public void deleteCountry(EntityManager em, Long countryId) {
    em.getTransaction().begin();
    Country country = em.find(Country.class, countryId);
    if (country != null) {
        em.remove(country);
    }
    em.getTransaction().commit();
}

@OneToOne

@OneToOne 관계는 하나의 엔티티가 다른 하나의 엔티티와 1:1로 연결되는 경우이다.

예시: 사용자와 프로필의 관계

User: 하나의 Profile을 가질 수 있다.
Profile: 하나의 User에 속할 수 있다.

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id")
    private Profile profile;

    // Getter, Setter, Constructor
}

@Entity
public class Profile {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String bio;

    // Getter, Setter, Constructor
}

데이터 저장, 수정, 삭제 예시

public void saveUserAndProfile(EntityManager em) {
    em.getTransaction().begin();

    User user = new User();
    user.setUsername("johndoe");

    Profile profile = new Profile();
    profile.setBio("Software Developer");

    user.setProfile(profile);

    em.persist(user);
    em.getTransaction().commit();
}

public void updateProfile(EntityManager em, Long profileId) {
    em.getTransaction().begin();
    Profile profile = em.find(Profile.class, profileId);
    if (profile != null) {
        profile.setBio("Senior Software Developer");
    }
    em.getTransaction().commit();
}

public void deleteUser(EntityManager em, Long userId) {
    em.getTransaction().begin();
    User user = em.find(User.class, userId);
    if (user != null) {
        em.remove(user);
    }
    em.getTransaction().commit();
}

@ManyToMany

@ManyToMany 관계는 여러 엔티티가 서로 다수와 연결될 수 있는 경우이다.

예시: 학생과 수업의 관계

Student: 여러 Course를 수강할 수 있다.
Course: 여러 Student가 수강할 수 있다.

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    // Getter, Setter, Constructor
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();

    // Getter, Setter, Constructor
}

데이터 저장, 수정, 삭제 예시

public void saveStudentAndCourses(EntityManager em) {
    em.getTransaction().begin();

    Student student = new Student();
    student.setName("Alice");

    Course course1 = new Course();
    course1.setTitle("Mathematics");

    Course course2 = new Course();
    course2.setTitle("Physics");

    student.getCourses().add(course1);
    student.getCourses().add(course2);

    course1.getStudents().add(student);
    course2.getStudents().add(student);

    em.persist(student);
    em.getTransaction().commit();
}

public void updateCourseTitle(EntityManager em, Long courseId) {
    em.getTransaction().begin();
    Course course = em.find(Course.class, courseId);
    if (course != null) {
        course.setTitle("Advanced Mathematics");
    }
    em.getTransaction().commit();
}

public void deleteStudent(EntityManager em, Long studentId) {
    em.getTransaction().begin();
    Student student = em.find(Student.class, studentId);
    if (student != null) {
        em.remove(student);
    }
    em.getTransaction().commit();
}

엔티티 상속

JPA는 엔티티 간의 상속 관계를 정의할 수 있다. 주요 상속 전략으로는 SINGLE_TABLE, JOINED, TABLE_PER_CLASS가 있다.

SINGLE_TABLE 전략

모든 엔티티를 하나의 테이블에 저장하고, 구분 컬럼을 사용하여 각 엔티티 유형을 식별하는 전략이다.

예시

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "employee_type")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getter, Setter, Constructor
}

@Entity
@DiscriminatorValue("MGR")
public class Manager extends Employee {
    private String department;

    // Getter, Setter, Constructor
}

@Entity
@DiscriminatorValue("ENG")
public class Engineer extends Employee {
    private String specialty;

    // Getter, Setter, Constructor
}

JOINED 전략

각 엔티티를 별도의 테이블에 저장하고, 기본 키를 사용하여 상속 계층 구조를 연결하는 전략이다.

예시

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getter, Setter, Constructor
}

@Entity
public class Manager extends Employee {
    private String department;

    // Getter, Setter, Constructor
}

@Entity
public class Engineer extends Employee {
    private String specialty;

    // Getter, Setter, Constructor
}

TABLE_PER_CLASS 전략

각 엔티티를 별도의 테이블에 저장하고, 각 테이블이 상속된 모든 속성을 가지는 전략이다.

예시

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;

    // Getter, Setter, Constructor
}

@Entity
public class Manager extends Employee {
    private String department;

    // Getter, Setter, Constructor
}

@Entity
public class Engineer extends Employee {
    private String specialty;

    // Getter, Setter, Constructor
}

데이터 저장, 수정, 삭제 예시

public void saveEmployeeAndManager(EntityManager em) {
    em.getTransaction().begin();

    Employee employee = new Employee();
    employee.setName("John Smith");

    Manager manager = new Manager();
    manager.setName("Jane Doe");
    manager.setDepartment("HR");

    em.persist(employee);
    em.persist(manager);
    em.getTransaction().commit();
}

public void updateManagerDepartment(EntityManager em, Long managerId) {
    em.getTransaction().begin();
    Manager manager = em.find(Manager.class, managerId);
    if (manager != null) {
        manager.setDepartment("Finance");
    }
    em.getTransaction().commit();
}

public void deleteEmployee(EntityManager em, Long employeeId) {
    em.getTransaction().begin();
    Employee employee = em.find(Employee.class, employeeId);
    if (employee != null) {
        em.remove(employee);
    }
    em.getTransaction().commit();
}

결론

JPA는 엔티티 간의 다양한 관계를 정의하고 관리할 수 있는 강력한 기능을 제공한다. @OneToMany, @ManyToOne, @OneToOne, @ManyToMany를 통해 데이터베이스 모델을 객체 지향적으로 표현할 수 있다. 또한, 상속 매핑 전략(SINGLE_TABLE, JOINED, TABLE_PER_CLASS)을 통해 엔티티 간의 상속 관계를 효과적으로 구현할 수 있다.

로깅(SLF4J)

h_jinnny — Thu, 30 May 2024 03:13:10 +0900

소프트웨어 개발에서 로깅은 디버깅과 모니터링에 필수적인 요소이다. 자바 환경에서는 다양한 로깅 프레임워크가 존재하지만, 이러한 프레임워크를 통합적으로 관리하기 위해 SLF4J(Simple Logging Facade for Java)가 등장했다. 이 글에서는 SLF4J의 개념, 장점, 사용법, 그리고 실제 코드 예제를 통해 SLF4J에 대해 알아보자.

SLF4J란?

SLF4J는 자바에서 다양한 로깅 프레임워크에 대한 추상화된 인터페이스를 제공하는 통합 로깅 API이다. SLF4J는 로깅 프레임워크의 구현체에 의존하지 않고, 애플리케이션 코드에서 일관된 로깅 인터페이스를 사용할 수 있게 해준다. 대표적인 로깅 프레임워크로는 Logback, Log4j, Java Util Logging 등이 있다.

주요 특징

통합 인터페이스: 여러 로깅 프레임워크를 일관된 방식으로 사용할 수 있다.
유연성: 실행 시점에 사용할 로깅 구현체를 쉽게 변경할 수 있다.
성능 최적화: 불필요한 문자열 연산을 피하기 위한 지연 로깅을 지원한다.

SLF4J의 장점

로깅 프레임워크 교체 용이: SLF4J를 사용하면 로깅 프레임워크를 교체할 때 애플리케이션 코드를 수정할 필요 없이 설정만 변경하면 된다.
일관된 API 사용: 다양한 로깅 프레임워크의 API 차이를 신경쓰지 않고, SLF4J의 일관된 API를 사용할 수 있다.
성능 개선: SLF4J는 로깅 메시지의 생성을 지연시켜 성능을 최적화할 수 있다.

SLF4J 사용법

의존성 설정

- Maven을 사용하여 SLF4J와 Logback을 프로젝트에 추가하는 방법은 다음과 같다:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

- Gradle을 사용하는 경우:

implementation 'org.slf4j:slf4j-api:1.7.30'
implementation 'ch.qos.logback:logback-classic:1.2.3'

로거 생성

SLF4J를 사용하여 로거를 생성하는 방법은 다음과 같다:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoggingExample {
    private static final Logger logger = LoggerFactory.getLogger(LoggingExample.class);

    public static void main(String[] args) {
        logger.info("This is an info message");
        logger.debug("This is a debug message");
        logger.error("This is an error message");

        int value = 42;
        logger.info("The value is {}", value);
    }
}

로깅 레벨

SLF4J는 여러 로깅 레벨을 제공한다. 주요 로깅 레벨은 다음과 같다:

TRACE: 가장 상세한 로깅 레벨로, 주로 개발 및 디버깅 목적으로 사용된다.
DEBUG: 디버깅 정보를 제공하며, 개발 중에 유용하다.
INFO: 일반적인 정보를 제공하며, 애플리케이션의 정상 동작을 알리는 메시지를 기록한다.
WARN: 경고를 의미하며, 잠재적인 문제를 기록한다.
ERROR: 오류를 의미하며, 애플리케이션의 문제를 기록한다.

지연 로깅

SLF4J는 문자열 연산의 비용을 줄이기 위해 지연 로깅을 지원한다. 아래 예제는 문자열 연결 연산을 피하는 방법을 보여준다:

int value = 42;
logger.debug("The value is {}", value);

SLF4J와 Logback 설정

SLF4J는 기본적으로 Logback을 사용하여 로깅을 처리한다. Logback의 설정 파일인 logback.xml을 통해 로깅 설정을 변경할 수 있다.

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>

</configuration>

위 설정은 콘솔에 로그 메시지를 출력하도록 설정하며, 로그 메시지의 형식을 정의한다.

SLF4J는 자바 애플리케이션에서 다양한 로깅 프레임워크를 통합적으로 관리할 수 있게 해주는 유용한 라이브러리이다. SLF4J를 사용하면 로깅 프레임워크를 쉽게 교체할 수 있고, 일관된 API를 통해 로깅을 처리할 수 있다. 또한 성능 최적화를 위한 지연 로깅 기능도 제공한다. SLF4J와 함께 Logback을 사용하여 강력하고 유연한 로깅 설정을 구성할 수 있다.

JPA와 ORM

h_jinnny — Thu, 30 May 2024 03:03:56 +0900

Java Persistence API (JPA)는 자바 플랫폼에서 객체 관계 매핑(ORM) 기술을 위한 표준이다.

ORM(Object-Relational Mapping)은 객체 지향 프로그래밍 언어의 객체를 관계형 데이터베이스의 테이블과 매핑하는 기술이다.

이 글에서는 JPA의 핵심 요소인 EntityManagerFactory, EntityManager, persist 등에 대해 상세히 알아보고, JPA 구현체 중 하나인 Hibernate에 대해서도 설명할 것이다.

ORM과 Hibernate

ORM (Object-Relational Mapping)

ORM은 객체 지향 프로그래밍 언어의 객체와 관계형 데이터베이스의 테이블 사이의 변환을 자동화하는 기술이다. ORM을 사용하면 SQL 쿼리를 직접 작성하지 않고도 데이터베이스와 상호작용할 수 있다. ORM의 주요 장점은 다음과 같다:

생산성 향상: 데이터베이스와의 상호작용을 추상화하여 개발 생산성을 높일 수 있다.
유지보수 용이: 코드가 간결해지고, 데이터베이스 스키마 변화에 유연하게 대응할 수 있다.
객체 지향적 프로그래밍: 객체 지향 패러다임에 맞는 코드를 작성할 수 있다.

Hibernate

Hibernate는 JPA의 가장 널리 사용되는 구현체 중 하나로, 강력하고 유연한 ORM 프레임워크이다. Hibernate는 JPA 표준을 구현하며, 추가적인 기능을 제공한다. Hibernate를 사용하면 JPA의 장점을 활용하면서도 다양한 확장 기능을 사용할 수 있다.

JPA의 주요 요소

EntityManagerFactory와 EntityManager

JPA에서 데이터베이스와의 상호작용을 관리하는 주요 인터페이스는 EntityManagerFactory와 EntityManager이다.

EntityManagerFactory: JPA 애플리케이션에서 데이터베이스와의 연결을 관리하는 팩토리 클래스이다. EntityManagerFactory는 애플리케이션 전체에서 하나만 생성되며, 여러 EntityManager 인스턴스를 생성하는 데 사용된다.
EntityManager: 실제 데이터베이스 작업을 수행하는 인터페이스이다. 데이터베이스 CRUD(Create, Read, Update, Delete) 작업을 관리하며, 엔티티의 생명주기를 관리한다.

EntityManager와 EntityManagerFactory 예제

다음은 EntityManagerFactory와 EntityManager를 사용하는 예제이다.

JPADemo.java

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

public class JPADemo {
    public static void main(String[] args) {
        // EntityManagerFactory 생성
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");

        // EntityManager 생성
        EntityManager em = emf.createEntityManager();

        // 트랜잭션 시작
        em.getTransaction().begin();

        // 새로운 엔티티 생성 및 저장
        Person person = new Person();
        person.setName("John Doe");
        em.persist(person);

        // 트랜잭션 커밋
        em.getTransaction().commit();

        // EntityManager 종료
        em.close();

        // EntityManagerFactory 종료
        emf.close();
    }
}

Person.java

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

설명

Persistence.createEntityManagerFactory("my-persistence-unit"): persistence.xml 파일에서 정의한 my-persistence-unit 이름의 영속성 유닛을 기반으로 EntityManagerFactory를 생성하는 코드이다.
emf.createEntityManager(): EntityManagerFactory를 사용하여 EntityManager를 생성하는 코드이다.
em.getTransaction().begin(): 트랜잭션을 시작하는 코드이다.
em.persist(person): 새로운 엔티티를 데이터베이스에 저장하는 코드이다.
em.getTransaction().commit(): 트랜잭션을 커밋하여 변경사항을 데이터베이스에 반영하는 코드이다.
em.close(): EntityManager를 닫는 코드이다.
emf.close(): EntityManagerFactory를 닫는 코드이다.

JPA의 주요 메서드

persist

persist 메서드는 새로운 엔티티를 영속성 컨텍스트에 저장한다. 엔티티가 영속성 컨텍스트에 저장되면, 트랜잭션이 커밋될 때 데이터베이스에 반영된다.

find

find 메서드는 데이터베이스에서 엔티티를 조회한다.

Person foundPerson = em.find(Person.class, personId);

remove

remove 메서드는 영속성 컨텍스트에서 엔티티를 삭제한다.

em.remove(person);

merge

merge 메서드는 분리된(Detached) 엔티티를 영속성 컨텍스트에 병합한다.

Person mergedPerson = em.merge(detachedPerson);

결론

JPA와 Hibernate는 자바 애플리케이션에서 데이터베이스와의 상호작용을 단순화하고, 생산성을 향상시키는 강력한 도구이다. EntityManagerFactory와 EntityManager는 JPA의 핵심 요소로, 데이터베이스 연결을 관리하고 CRUD 작업을 수행한다.

persist, find, remove, merge와 같은 주요 메서드를 사용하여 엔티티의 생명주기를 관리할 수 있다.

Hibernate는 JPA의 표준 구현체로, 추가적인 기능과 유연성을 제공하여 더욱 강력한 데이터베이스 관리를 가능하게 한다.

JPA 기초 개념과 코드 예제 (Spring JPA 아님!!)

h_jinnny — Tue, 28 May 2024 09:46:01 +0900

JPA(Java Persistence API)는 자바에서 관계형 데이터베이스를 다루기 위한 표준 API이다. JPA를 사용하면 객체 지향적인 방식으로 데이터베이스 작업을 처리할 수 있다. JPA의 주요 개념과 이를 활용한 코드 예제를 작성하겠다.

엔티티(Entity)

엔티티(Entity)는 데이터베이스 테이블과 매핑되는 클래스이다. JPA를 사용하면 데이터베이스의 테이블을 객체 지향적으로 표현할 수 있다. 엔티티 클래스는 @Entity 어노테이션을 사용하여 정의하며, 각 필드는 데이터베이스 테이블의 컬럼에 매핑된다.

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

@Entity
@Table(name = "jpa_user")
@NoArgsConstructor
@Getter
@Setter
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

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

위 코드에서 User 클래스는 jpa_user 테이블과 매핑되며, id, name, email 필드는 각각 테이블의 컬럼에 매핑된다. @GeneratedValue 어노테이션은 id 필드가 자동으로 생성되는 값임을 나타낸다.

엔티티매니저팩토리(EntityManagerFactory)

엔티티매니저팩토리(EntityManagerFactory)는 JPA에서 엔티티매니저(EntityManager)를 생성하는 역할을 한다. 애플리케이션 전체에서 하나만 생성되어야 하며, 생성 비용이 크기 때문에 보통 애플리케이션이 시작될 때 한 번만 생성하고 공유한다.

import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

public class JpaExample {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("UserPU");
        // 엔티티매니저팩토리 생성
    }
}

엔티티매니저(EntityManager)

엔티티매니저(EntityManager)는 엔티티를 관리하는 주요 객체이다. 엔티티의 생명주기를 관리하며, 데이터베이스 작업을 처리한다. 엔티티매니저를 통해 데이터베이스 트랜잭션을 시작, 커밋, 롤백할 수 있다. 엔티티매니저는 엔티티매니저팩토리에서 생성된다.

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

public class JpaExample {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("UserPU");
        EntityManager em = emf.createEntityManager(); // 엔티티매니저 생성

        em.getTransaction().begin(); // 트랜잭션 시작

        User user = new User("John Doe", "john@example.com");
        em.persist(user); // 엔티티 저장

        em.getTransaction().commit(); // 트랜잭션 커밋

        em.close(); // 엔티티매니저 종료
        emf.close(); // 엔티티매니저팩토리 종료
    }
}

영속성 컨텍스트(Persistence Context)

영속성 컨텍스트(Persistence Context)는 엔티티를 영구 저장소에 저장하는 환경을 의미한다. 엔티티매니저는 영속성 컨텍스트를 통해 엔티티를 관리한다. 영속성 컨텍스트는 엔티티의 상태를 관리하며, 동일한 영속성 컨텍스트 내에서는 동일한 엔티티가 공유된다. 이를 통해 1차 캐시 기능을 제공하여 성능을 최적화한다.

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

public class JpaExample {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("UserPU");
        EntityManager em = emf.createEntityManager(); // 엔티티매니저 생성

        em.getTransaction().begin(); // 트랜잭션 시작

        User user = new User("John Doe", "john@example.com");
        em.persist(user); // 엔티티 저장 (영속 상태)

        User foundUser = em.find(User.class, user.getId()); // 영속성 컨텍스트에서 조회
        System.out.println(foundUser.getName()); // "John Doe"

        em.getTransaction().commit(); // 트랜잭션 커밋

        em.close(); // 엔티티매니저 종료
        emf.close(); // 엔티티매니저팩토리 종료
    }
}

META-INF

META-INF는 JAR 파일의 메타데이터를 저장하는 디렉토리이다. JPA 설정 파일인 persistence.xml은 이 디렉토리에 위치해야 한다. persistence.xml 파일은 영속성 유닛을 정의하고, 데이터베이스 연결 설정, JPA 구현체, 엔티티 클래스를 설정한다.

META-INF/
    persistence.xml

persistence.xml

persistence.xml은 JPA 설정 파일로, 영속성 유닛(Persistence Unit)을 정의한다. 이 파일은 META-INF 디렉토리에 위치하며, 데이터베이스 연결 정보와 JPA 구현체를 설정한다.

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">

    <persistence-unit name="UserPU" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>com.example.jpa.User</class>  <!-- Add this line -->
        <properties>
            <property name="jakarta.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3307/exam"/>
            <property name="jakarta.persistence.jdbc.user" value="jeon"/>
            <property name="jakarta.persistence.jdbc.password" value="1234"/>

            <!--create, update, create-drop, validate, none 중에 하나를 지정할 수 있음-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>

            <!--사용할 데이터베이스 방언을 지정한다-->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>

            <!--: SQL 명령어를 콘솔에 출력하고 포맷팅할지 여부를 설정한다-->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

하이버네이트(Hibernate)

하이버네이트(Hibernate)는 JPA의 구현체 중 하나로, ORM(Object-Relational Mapping) 프레임워크이다. JPA 표준을 구현하고 있으며, 데이터베이스와 객체 지향 프로그래밍 간의 불일치를 해결해준다. 하이버네이트를 사용하면 SQL 쿼리를 작성하지 않고도 데이터베이스 작업을 객체 지향적으로 수행할 수 있다.

JPA는 객체와 관계형 데이터베이스 간의 매핑을 간단하게 처리할 수 있도록 도와주는 강력한 프레임워크이다. 이를 통해 개발자는 객체 지향 프로그래밍 패러다임을 유지하면서도 데이터베이스 작업을 효율적으로 수행할 수 있다.

Spring MVC의 @RequestParam과 @PathVariable 사용법

h_jinnny — Thu, 23 May 2024 10:00:47 +0900

Spring MVC는 웹 애플리케이션을 쉽게 만들 수 있는 다양한 어노테이션을 제공하는 프레임워크이다. 이 중 @RequestParam과 @PathVariable은 URL로부터 파라미터를 추출하는 데 사용된다. 이 글에서는 이 두 어노테이션의 차이점과 사용법을 자세히 살펴보겠다.

@RequestParam

@RequestParam 어노테이션은 HTTP 요청의 파라미터를 메서드의 파라미터로 바인딩하는 데 사용된다. GET 요청이나 POST 요청에서 쿼리 스트링 또는 폼 데이터를 쉽게 처리할 수 있다.

예제 1: 기본 사용법

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class RequestParamController {

    @GetMapping("/greeting")
    public String greeting(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
        model.addAttribute("name", name);
        return "greeting";
    }
}

설명

@RequestParam(name = "name", required = false, defaultValue = "World")는 URL 쿼리 파라미터 name을 메서드 파라미터 name에 바인딩하는 것이다.
required가 false로 설정되어 있어 name 파라미터가 없어도 에러가 발생하지 않는다. defaultValue는 파라미터가 없을 때 사용할 기본값을 지정하는 것이다.

결과

URL: http://localhost:8080/greeting?name=John
URL: http://localhost:8080/greeting

@PathVariable

@PathVariable 어노테이션은 URL 경로에 있는 값을 메서드의 파라미터로 바인딩하는 데 사용된다. RESTful 웹 서비스에서 자주 사용된다.

예제 2: 기본 사용법

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

@Controller
public class PathVariableController {

    @GetMapping("/user/{userId}")
    @ResponseBody
    public String getUser(@PathVariable("userId") String userId) {
        return "User ID: " + userId;
    }
}

설명

@PathVariable("userId")는 URL 경로에서 {userId} 부분을 메서드 파라미터 userId에 바인딩하는 것이다.
@ResponseBody는 반환 값을 HTTP 응답 본문으로 직접 보내는 데 사용된다.

결과

URL: http://localhost:8080/user/123

@RequestParam과 @PathVariable의 차이점

위치: @RequestParam은 쿼리 스트링 또는 폼 데이터에서 값을 가져오고, @PathVariable은 URL 경로에서 값을 가져오는 것이다.
용도: @RequestParam은 주로 필터링, 검색, 페이징 등에 사용되며, @PathVariable은 RESTful 서비스에서 리소스를 식별하는 데 사용된다.

두 어노테이션을 같이 사용하는 예제

두 어노테이션을 함께 사용하는 예제를 보겠다.

예제 3: 복합 사용

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class CombinedController {

    @GetMapping("/products/{productId}")
    public String getProduct(@PathVariable("productId") String productId, @RequestParam(name = "category", required = false) String category, Model model) {
        model.addAttribute("productId", productId);
        model.addAttribute("category", category);
        return "product";
    }
}

product.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Product</title>
</head>
<body>
<h1>Product Details</h1>
<p>Product ID: <span th:text="${productId}"></span></p>
<p>Category: <span th:text="${category}"></span></p>
</body>
</html>

설명

@PathVariable("productId")는 URL 경로에서 {productId} 값을 추출하는 것이다.
@RequestParam(name = "category", required = false)는 쿼리 스트링에서 category 값을 추출하는 것이다.

결과

URL: http://localhost:8080/products/456?category=Electronics
URL: http://localhost:8080/products/456

결론

Spring MVC의 @RequestParam과 @PathVariable 어노테이션은 웹 애플리케이션에서 URL로부터 파라미터를 추출하는 데 매우 유용하다. @RequestParam은 쿼리 스트링 또는 폼 데이터를 처리하는 데 사용되고, @PathVariable은 URL 경로의 변수를 처리하는 데 사용된다. 이 두 어노테이션을 적절히 활용하면 더욱 유연하고 강력한 웹 애플리케이션을 개발할 수 있다.