기발자

스웨거(OpenAPI) 로 API 명세서 자동화 하기

kibal.countinue — Thu, 30 Nov 2023 18:58:49 +0900

프론트 개발자, 기획자 등과 커뮤니케이션 할 때, 기능을 추상화 하여 커뮤니케이션 할 수도 있지만, request 와 response 를 통해 커뮤니케이션 하는 것이 혼선을 줄일 수 있는 좋은 방법이라고 생각한다.

Swagger (OpenAPI 와 통합) 를 통해 프론트엔드 연동, QA 등에서 정상동작 여부 및 오류 확인 등의 기준이 되는 API 를 확인해보자.

스웨거를 적용한 환경은 Springboot 2.7.15 버전이다.

1. build.gradle 내 Dependency 추가하기

implementation "io.springfox:springfox-boot-starter:3.0.0"
implementation "io.springfox:springfox-swagger-ui:3.0.0"

'springfox-boot-starter' : SpringBoot 에 Swagger 를 통합하기 위한 스타터 패키지. 모든 컨트롤러와 모델 클래스를 스캔하여 API 문서를 자동으로 생성함.

'springfox-swagger-ui' : SwaggerUI를 제공함. 로컬 접속 시 http://localhost:8080/swagger-ui/index.html#/ 경로를 통해 접근할 수 있음.

2. application.yml 설정하기

spring:
  mvc:
    pathmatch:
      matching-strategy: ant-path-matcher

내 프로젝트의 환경인 Springboot 2.7.15 버전에서는 URL 매칭 전략을 추가로 설정해야 했다.
설정하지 않으면 documentationPluginsBootstrapper 빈에서 ApplicationContextException 에러가 발생하는 것을 경험했다. (스프링부트 버전과 스프링폭스 3.0 버전의 경로패턴 호환성이 맞지 않는것 같다.)

2. SwaggerConfig 클래스 생성하기

package com.iamcaster.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

@Configuration
public class SwaggerConfig {

    @Bean
    public Docket api() {  // Docket:API 문서화 구성
        return new Docket(DocumentationType.OAS_30)//OpenAPI Spec 3.0 사용
        		.groupName("general") // 문서의 그룹 지정 가능. 
                .useDefaultResponseMessages(false) // 기본 HttpCode 사용여부 설정
                .select() // 스캔할 API 범위 지정
                .apis(RequestHandlerSelectors.basePackage("com.iamcaster"))
                .paths(PathSelectors.any())
                .build()
                .apiInfo(apiInfo());
    }
    
    private ApiInfo apiInfo() { // API 문서의 메타데이터 정의
        return new ApiInfoBuilder()
                .title("iamcaster api docs")
                .description("iamcaster api list")
                .version("1.0")
                .build();
    }
}

Docket 클래스의 주요 메소드

메소드 설명

apiInfo(ApiInfo apiInfo) API의 메타데이터를 설정. (제목, 설명, 버전 등)

groupName(String groupName) API 문서의 그룹 이름을 설정.

select() ApiSelectorBuilder를 반환하여, API를 선택하고 세부 사항을 설정.

enable(boolean enabled) Swagger를 활성화하거나 비활성화.

protocols(Set<String> protocols) 지원하는 프로토콜을 설정. (예: "http", "https")

host(String host) API 문서에 사용할 호스트 이름을 설정.

directModelSubstitute(Class<?> originalClass, Class<?> substituteClass) 특정 클래스를 다른 클래스로 대체. (모델 대체)

alternateTypeRules(AlternateTypeRules alternateTypeRules) 주어진 타입 규칙에 따라 모델을 변경.

useDefaultResponseMessages(boolean useDefaultResponseMessages) 기본 응답 메시지 사용 여부를 설정.

globalResponseMessage(RequestMethod method, List<ResponseMessage> responseMessages) 특정 HTTP 메소드에 대한 전역 응답 메시지를 설정.

securitySchemes(List<? extends SecurityScheme> securitySchemes) 보안 스키마를 설정. (예: API 키, OAuth2)

securityContexts(List<SecurityContext> securityContext) 보안 컨텍스트를 설정.

tags(Tag tags) API 문서에 사용할 태그를 설정.

pathMapping(String path) 기본 경로 매핑을 설정.

3. Controller 에 매핑하기

@Api(tags = {"회원정보 등록, 수정, 삭제"}) // Swagger 문서화 메타데이터.
@RequestMapping("/rest")
@RestController
public class UserInfoRestController {
	@ApiOperation(value="선택약관 동의여부") // endpoint 별 설명
	@ApiResponses(value = { // response 별 설명
	@ApiResponse(code = 200, message = "성공적으로 처리됨", response = ResultResponse.class),
	@ApiResponse(code = 400, message = "잘못된 요청"),
	@ApiResponse(code = 500, message = "서버 오류")
	})
	@GetMapping("/terms/optionalAgreed")
	public ResultResponse optionaltermsUpdate(@RequestParam("UID") int UID, 
			@ApiParam("ifAgreed") // API 파라미터 별 설명
            @RequestParam("ifAgreed") boolean ifAgreed){
		ResultResponse result = new ResultResponse();
		int isAgreed = userInfoService.optionalTermsSubmit(UID, ifAgreed);
		if(isAgreed == 1) {
			result.setResult("success");
		} else {
			result.setResult("fail");
		};
		return result;
	};
 }

컨트롤러에 설정된 어노테이션 별 정의 :

@Api: 클래스에 Swagger 문서화 메타데이터.
- tags: 이 API를 어떤 태그로 분류할지 지정.
- value: API에 대한 짧은 설명.
- description: API에 대한 보다 자세한 설명.

@ApiOperation: 특정 API 연산에 대한 정보.
- value: API 연산에 대한 짧은 설명.
- notes: API 연산에 대한 보다 자세한 정보.

@ApiParam: API 연산에서 파라미터에 대한 메타데이터.
- value: 파라미터에 대한 설명.
- required: 파라미터가 필수인지 여부를 나타냄.
- example: 파라미터의 예시 값.

@ApiResponse: API 응답에 대한 정보를 정의.
- code: HTTP 응답 코드를 지정.
- message: 응답 코드에 따른 설명.
- response: 응답 본문의 타입.

4. 객체에 매핑하기

package com.iamcaster.user.domain;

import io.swagger.annotations.ApiModelProperty;

public class UserInfo {

	@ApiModelProperty(value = "사용자Key", example = "1")
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int UID;

	@ApiModelProperty(value = "사용자ID", example = "abc@iam.cater")
	private String email;
	
	@ApiModelProperty(value = "사용자비밀번호", example = "abc123abc")
	private String password;

	private String salt;
	
	@ApiModelProperty(value = "닉네임Key", example = "1")
	@Column(name="NickID")
	private int NickID;

	@ApiModelProperty(value = "사용자지역Key", example = "1")
	private int RGID;
	
	@ApiModelProperty(value = "선택약관 동의 철회 일시", example = "2022-04-18T09:00:00+09:00[Asia/Seoul]")
	@Column(name="optionalTerms")
	private ZonedDateTime optionalTerms;
	
	@Column(name="createdAt", updatable=false)
	@UpdateTimestamp
	private ZonedDateTime createdAt;
	
	@Column(name="updatedAt")
	@UpdateTimestamp
	private ZonedDateTime updatedAt;
	
	@ApiModelProperty(value = "카카오 연동 여부", example = "true")
	@Column(name="ifKakao")
	private boolean ifKakao;
	
	@Transient
	private boolean ifOptionalTermsAgreed;
	
}

객체에 설정된 어노테이션

@ApiModel: 도메인 객체에 대한 추가 정보.
- value: 필드명.
- description: 필드 정보.

Swagger UI 에서 확인하기

http://localhost:8080/swagger-ui/index.html#/ 경로에서 Swagger UI 를 확인할 수 있다.

이제 실제로 서버에 적용되어 있는 API 를 Swagger UI를 통해 확인할 수 있다.

GitHub Actions 로 Docker 빌드 및 자동 배포하기

kibal.countinue — Mon, 20 Nov 2023 23:36:46 +0900

깃허브 액션을 사용하면 소스코드의 변경 후 git push 시, 자동으로 어플리케이션 빌드, 도커 이미지 생성 및 배포를 할 수 있다.

이 게시글은 전체적인 틀에 대한 제시이며, 각 프로젝트의 환경에 따라 프로세스를 가감 하여 사용할 수 있다.

* 도커 적용과 도커파일 관련 내용은 아래 게시글에서 확인할 수 있다.

Docker 로 SpringBoot 프로젝트 배포하기 - 이미지 빌드 해서 Docker Hub에 푸시

기존 내 프로젝트는 war 파일을 톰캣 매니저 페이지를 통해 배포하는 방법을 채택했었다. 다만 프로젝트를 변경해 나가는 과정에서, ec2 인스턴스를 새로 설정하게 되는 경우가 발생하는데, 이때

joelinseoul.tistory.com

예시로 활용된 프로젝트의 환경은 아래와 같다.

프로젝트 환경
- java 스프링부트
- gradle
- 도커

개념

Git Hub 레파지토리에 변경사항이 발생되면, 사용자가 정의한 순서대로 jobs 를 실행해 나간다.

이러한 흐름을 정의 하는 스크립트 파일은 .github/workflows/ci-cd.yaml 의 형태에 맞는 경로로 저장해 주며, 파일명은 무관하다.

내 프로젝트의 환경에 맞춘 (gradle빌드 및 ec2 내 도커 배포) workflows의 yaml 의 흐름은 아래와 같다.

레파지토리 체크아웃

▼

gradle wrapper 파일 실행권한 추가

▼

./gradlew build 실행

▼

Docker Hub 에 로그인

▼

도커 이미지 빌드 및 Docker Hub에 푸시

▼

ec2 접속 및 도커 기존 컨테이너 삭제,
신규 컨테이너 run

( GitHub Actions 스크립트의 큰 흐름)

.github/workflows/ci-cd.yaml 파일 설정

name: CI/CD Pipeline
# ▽ aws 라는 이름의 브랜치에 push 발생 시 해당 스크립트 실행.
on:
  # ▽ 수동으로 동작시킬 수 있도록 이벤트 트리거 추가
  workflow_dispatch:
  push:
    branches:
      - aws
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout Repository
      uses: actions/checkout@v2
      
 # ▽ 프로젝트의 JDK 버전 명시
    - name: Set up JDK 17
      uses: actions/setup-java@v2
      with:
        java-version: '17'
        distribution: 'adopt'      
# ▽ GitHub Actions에서 gradlew 스크립트를 실행시키기 위해, 실행 권한을 부여 함.
    - name: Set up Executable Permission for Gradlew
      run: chmod +x ./gradlew
# ▽ 애플리케이션 빌드
    -  name: Build and Test
       run: ./gradlew build
# ▽ 도커 허브 로그인 (깃허브의 secrets 내 변수로 username, password 치환)
    - name: Login to Docker Hub
      uses: docker/login-action@v1
      with:
        username: ${{ secrets.DOCKER_HUB_USERNAME }}
        password: ${{ secrets.DOCKER_HUB_PW }}
# ▽ 도커 이미지 빌드 및 푸시        
    - name: Build and Push Docker Image
      run: |
        docker build -t joelgyunampark/iamcaster:${{ github.sha }} .
        docker push joelgyunampark/iamcaster:${{ github.sha }}
# ▽ EC2 접속
    - name: Deploy to AWS EC2
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.EC2_HOST }}
        username: ${{ secrets.EC2_USERNAME }}
        key: ${{ secrets.EC2_SSH_KEY }}
# ▽ EC2에서 docker 이미지 pull, 기존 컨테이너 중지 삭제 및 새 이미지 run
        script: |
          docker pull joelgyunampark/iamcaster:${{ github.sha }}
          docker stop myapp || true
          docker rm myapp || true
          docker run -d --name myapp -p 80:8080 joelgyunampark/iamcaster:${{ github.sha }}

GitHub secrets 변수 설정

위의 workflows yaml 스크립트 내 ${{ secrets.xxxx }} 에 치환 될 값을 설정해야 한다.

github repository > Settings > Secrets and variables > Actions > New repository secret

Name : 변수명 Secret : 값

동작 확인 해보기

workflow_dispatch event trigger 를 추가하였으므로, 아래 스크린샷과 같이 수동으로 Run workflow를 할 수 있다.

배포 환경의 브런치를 선택 후 Run workflow 를 하면 동작이 시작된다.

- 실행 시, workflow 의 스크립트 순서대로 실행되는 것을 확인할 수 있다.

- 성공의 예 :

아래와 같이 successed now 메세지를 받으면 도커 컨테이너 실행까지 완료된 것.

- 실패의 예 :

실패하면 에러코드를 확인해 본다. 그래들 래퍼의 권한을 부여하지 않아 실패된 케이스다.

이 실패케이스를 통해 위의 예시 yaml 파일에 run: chmod +x ./gradlew 를 추가할 수 있었다.

이제 배포 환경 브랜치를 push 하면 자동으로 배포되게 되었다.

디자인패턴 - 팩토리 패턴

kibal.countinue — Wed, 8 Nov 2023 01:02:03 +0900

팩토리 패턴의 개념

팩토리 패턴 (Factory Pattern)은 객체를 사용하는 코드에서, 객체 생성 부분을 떼어내 추상화 한 패턴.
상속 관계에 있는 두 클래스에서 상위클래스는 중요 뼈대를 결정하고, 하위 클래스에서 객체 생성에 관한 구체적인 내용을 결정하는 패턴.

팩토리 패턴의 특징

상위 클래스와 하위클래스가 분리되기 때문에, 느슨한 결합을 가짐.
상위클래스에서는 인스턴스의 생성 방식에 대해서 알 필요가 없기 때문에 유연성을 가짐.
유지보수성의 증가 : 객체 생성 로직이 따로 떼어져 있기 때문에, 코드를 리팩토링하더라도 한 곳만 고칠 수 있게 됨.

Java 에서의 팩토리 패턴 적용 예시

package csstudy.tistory;

public class FactoryPatternExample {
	// 상위 클래스(추상화 클래스) : 문구류 정보의 뼈대 제공.
    // 모든 문구류는 이 클래스를 상속 받아야 함.
	abstract static class Stationary{
    	//추상 메소드 : 가격을 반환.
		public abstract int getPrice();
        //추상 메소드 : 이름을 반환.
		public abstract String getName();
		
		@Override
		public String toString() {
			return this.getName()+"의 가격 : " + this.getPrice()+"원";
		}
	}
    // 하위클래스 : 문구류 정보 안내 클래스에 상속
	static class DefaultPen extends Stationary{
		private int price;
		private String name;
		
		public DefaultPen(int price) {
			this.price = price;
			this.name = "기본펜";
		}
		@Override
		public int getPrice() {
			return this.price;
		}
		@Override
		public String getName() {
			return this.name;
		}
	}
	static class Ballpen extends Stationary{
		private int price;
		private String name;
		
		public Ballpen(int price) {
			this.price = price;
			this.name = "볼펜"
;		}
		@Override
		public int getPrice() {
			return this.price;
		}
		@Override
		public String getName() {
			return this.name;
		}
	}
	static class Pencil extends Stationary{
		private int price;
		private String name;
		public Pencil(int price) {
			this.price = price;
			this.name = "연필";
		}
		@Override
		public int getPrice() {
			return this.price;
		}
		@Override
		public String getName() {
			return this.name;
		}
	}
	// 팩토리 클래스 : 문자열 타입에 따라 문구류 객체를 생성하고 반환함.
	static class StationaryFactory{
		public static Stationary getStationary(String type, int price) {
			if("Ballpen".equalsIgnoreCase(type)) {
				return new Ballpen(price);
			} else if("Pencil".equalsIgnoreCase(type)) {
				return new Pencil(price);
			} else {
				return new DefaultPen(price);
			}
		}
	}
    // 300원짜리 연필 구하기
    public static void main(String[] args) {
		Stationary pencil = StationaryFactory.getStationary("Pencil",300);
		System.out.println(pencil);
	}
}

코드 실행 결과

- Stationary 추상 클래스는 문구류 객체의 뼈대를 제공
- StationaryFactory 클래스는 문구류 객체를 생성하는 과정을 캡슐화.

Javascript 에서의 팩토리 패턴 적용 예시

<script>

    class Ballpen {
        constructor(){
            this.name="ballpen";
        }
    }
    class Pencil{
        constructor(){
            this.name="pencil";
        }
    }
    class BallpenMaker{
        static makeStationary(){
            return new Ballpen();
        }
    }
    class PencilMaker{
        static makeStationary(){
            return new Pencil();
        }
    }
    const makerList = {BallpenMaker, PencilMaker};
    class StationaryFactory{
        static createStationary(type){
            const maker = makerList[type];
            return maker.makeStationary()
        }
    }
    const main = (type) => {
        const stationary = StationaryFactory.createStationary(type);
        console.log(stationary.name);
    }

    main("BallpenMaker")
</script>

코드 실행 결과

- StationaryFactory :상위 클래스로, 문구류의 큰 뼈대 구조를 잡읍.
- BallpenMaker : 하위클래스로, 객체의 구체적인 내용을 결정함.
- 의존성 주입 : BallpenMaker 에서 생성한 인스턴스를 StationaryFactory에 주입.

디자인패턴 - 싱글톤 패턴

kibal.countinue — Wed, 8 Nov 2023 00:40:24 +0900

싱글톤 (Singleton) 패턴 핵심

하나의 클래스에 오직 하나의 인스턴스만 가지는 디자인 패턴.
클래스를 기반으로 단 하나의 인스턴스를 만들어, 이를 기반으로 로직을 만듦.
보통 데이터베이스 연결 모듈에서 주로 사용.
장점 : 하나의 인스턴스를 만들어 놓고, 해당 인스턴스를 다른 모듈들이 공유하여 사용하므로, 인스턴스를 생성할 때 드는 비용이 줄어듬.
단점 : 의존성이 높아짐 -> 각 테스트 마다 독립적인 인스턴스를 생성해야 하는 TTD(Test Driven Development) 적용이 어려움.

싱글톤 패턴의 의존성 주입

의존성 주입 개념 : 싱글톤 패턴은 모듈 간의 결합을 강하게 만들 수 있는 단점이 있음. → 이 때 의존성 주입을 통해 해결 가능.
중간에 의존성 주입자(depenency injector) 가 하위 모듈에게 의존성을 주고, 의존성 주입자와 메인모듈만 서로 연결하는 개념.
의존성 주입 원칙 : 상위 모듈은 하위 모듈에서 어떤 것도 가져오지 않아야 함. 또한 둘 다 추상화에 의존해야 하며, 이때 추상화는 세부사항에 의존하지 말아야 함.

의존성 주입 개념도

Java 에서의 싱글톤 패턴 적용 예시

package csstudy.tistory;

public class SingletonExample {

	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		boolean isSame = (instance1 == instance2);
		System.out.println(instance1.hashCode());
		System.out.println(instance2.hashCode());
		System.out.println(isSame);
	}
}

class Singleton{
	private static class singleInstanceHolder{
		private static final Singleton INSTANCE = new Singleton();
	}
	public static Singleton getInstance() {
		return singleInstanceHolder.INSTANCE;
	}
}

코드 실행 결과

- singleInstanceHolder 클래스의 Singleton 인스턴스가 static final 로 선언되어 있으므로, 클래스가 로딩되는 시점에 1개만 생성되며, 이후 추가 선언 시 해당 인스턴스를 가르키게 된다.
- 코드 실행 결과를 보면, instance1과 instance2 가 같은 해시코드 값을 가지고 있는 것을 확인할 수 있다.

Javascript 에서의 싱글톤 패턴 적용 예시

<script>
     class Singleton{
        constructor(){
            if(!Singleton.instance){
                Singleton.instance = this
            }
            return Singleton.instance
        }
    }
    const obj3 = new Singleton()
    const obj4 = new Singleton()
    console.log(obj3 === obj4)
</script>

코드 실행 결과

- 자바스크립트 에서의 싱글톤 적용은, Singleton 클래스의 생성자 호출 시 생성자 존재 여부를 확인 후,
있으면 새 인스턴스를 생성하는 대신 기존 인스턴스를 반환하게 된다.

ThymeLeaf 템플릿으로 JavaMailSender 활용, 자바 메일보내기

kibal.countinue — Wed, 1 Nov 2023 22:18:32 +0900

Spring 의 JavaMailSender 와 Thymeleaf의 템플릿 엔진을 사용하여 이메일을 생성하고 발송하는 기능을 구현해 본다.

흐름은 아래와 같다.

간단한 인증번호 전송 등의 기본 메일이라면, 아래의 모듈화 정도가 적당할 것 같다.

build.gradle 의존성 추가

JavaMailSender를 사용하기 위해 spring-boot-starter-mail 을 의존성 추가하고,
템플릿엔진을 사용하기 위해 spring-boot-starter-thymeleaf 를 의존성 추가한다.
	//메일발송
	implementation 'org.springframework.boot:spring-boot-starter-mail'
	//thymemeleaf
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'

application.yml 설정

JavaMailSender 를 사용하여 이메일을 보내기 위해, SMTP서버의 정보를 application.yml 에서 설정해 준다.
spring:
  mail:
    host: smtp.naver.com
    port: 587
    username: 아이디
    password: 비밀번호
    properties:
      mail:
        smtp:
          auth: true
          timeout: 5000
          starttls:
            enable: true
            required: true
- spring.mail.host : SMTP 서버의 호스트 명
- spring.mail.port : SMTP 서버의 포트번호
- spring.mail.usename : SMTP 서버 접속을 위한 사용자이름
- password : SMTP 서버 접속을 위한 비밀번호
- spring.mail.properties.mail.smtp.auth: SMTP 서버에 로그인할 때 인증을 사용할지 여부를 설정
- spring.mail.properties.mail.smtp.timeout: SMTP 서버에 연결할 때의 타임아웃 시간을 설정
- spring.mail.properties.mail.smtp.starttls.enable: STARTTLS를 사용하여 SMTP 서버에 연결할지 여부를 설정
- spring.mail.properties.mail.smtp.starttls.required: STARTTLS를 사용하여 SMTP 서버에 연결하는 것이 필수인지 여부를 설정

메일서비스 제공사마다 설정값들이 다르기 때문에, 네이버의 경우 상기 코드와 같이 작성하면 된다.
다른 메일서비스 제공사를 이용하고 싶다면 메일함에 들어가 설정 > POP/IMAP 설정 등과 같은 곳에 들어가 자신의 로그인ID, SMTP서버명, 포트번호 등을 확인해보자.

이어서, SpringBoot에서 Thymeleaf 템플릿 엔진을 사용하기 위한 설정 또한 해준다.
spring:
  thymeleaf:
    prefix: classpath:/templates/thymeleafTemplates/
    suffix: .html
    mode: HTML
    cache: false
    thymeleaf.view-names
- thymeleaf.prefix: 템플릿 파일의 경로의 접두사로 사용됨. classpath:/templates/thymeleafTemplates/로 설정되어 있어, src/main/resources/templates/thymeleafTemplates/ 경로에 있는 템플릿 파일들을 찾게 된다.
- thymeleaf.suffix: 템플릿 파일의 확장자를 설정
- thymeleaf.mode: 템플릿 엔진의 모드를 설정. HTML문법으로 작성된 파일을 처리함.
- thymeleaf.cache: 템플릿 파일의 캐싱 여부를 설정. 개발 환경이므로 false 하여 캐싱을 끔.
- thymeleaf.view-names: 템플릿 파일의 이름 패턴을 설정. JSP 등과 함께 사용하는 경우 충돌이 발생될 수 있는데, 이 설정 시 해당 텍스트로 시작하는 템플릿 파일만 찾음.

이제 환경설정은 완료되었다.

아래는 구현을 위한 코드이다.

DTO

메일 수신자, 발신자, 제목, 본문 을 구성하기 위한 DTO 이다.

package com.spingblog.cases.mailSender;

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

@ToString
@Builder(toBuilder = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class MailSenderDTO {

	private String receiver;
	private String sender;
	private String subject;
	private String context;
}

Controller : 응답 수신

컨트롤러는 서비스 마다 구현방법이 가지각색일것이다.
여기서는 최초 로직 시작이 되는 개념으로만 이해를 하면 된다.
who 변수에 수신이메일, what 변수에 메일본문을 입력하면 된다.
package com.spingblog.cases.mailSender;
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 MailSenderRestController {
	@Autowired
	private MailSenderService mailSenderService;
	@GetMapping("/send")
	public void sendRequest(@RequestParam("who") String who, @RequestParam("what") String what) {
		mailSenderService.send(who, what);
	}
}

Service : send

이메일을 받을 사람(who)과 이메일의 내용(what)을 인자로 받는다.
setContext 메서드를 호출하여 이메일 내용을 생성한다.
MailSenderDTO 객체를 생성하여 이메일의 수신자, 발신자, 제목, 내용 등을 설정한다.

sendEmail 메서드를 호출하여 이메일을 발송한다.

package com.spingblog.cases.mailSender;
import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
import org.thymeleaf.context.Context;
import org.thymeleaf.spring5.SpringTemplateEngine;

@Service
public class MailSenderService {

	@Autowired
	private JavaMailSender javaMailSender;
	@Autowired
	private SpringTemplateEngine templateEngine;

	// 메일 작성
	public void send(String who, String what) {
		
		String writeTL = setContext(what);
		MailSenderDTO mailDTO = MailSenderDTO.builder()
				.receiver(who)
				.sender("joeldev@naver.com")
				.subject("기발자로부터 메일이 도착했어요!")
				.context(writeTL)
				.build();
		sendEmail(mailDTO);
	}

	// 타임리프 본문 구성
	public String setContext(String what) {
		//중략
	}
	// 메일 발송
	public void sendEmail(MailSenderDTO mailDTO) {
		//중략
	}
}

service : setContext

- Context 객체를 생성하여 what을 변수로 설정한다.

* setVariable 에서 정의한 변수와 값은 타임리프 템플릿에서 <div th:text="${what}"/> 와 같이 구성하여 템플릿에서 치환된다.

- 타임리프 templateEngine을 사용하여 템플릿(tlTemplate)을 기반으로 이메일 내용을 생성한다.
* process(<html파일명>, <변수객체>) 와 같이 구성하여 해당 html파일을 변수객체로 치환하고, 치환된 html을 String으로 return 받는다.

package com.spingblog.cases.mailSender;
//중략
@Service
public class MailSenderService {

	@Autowired
	private JavaMailSender javaMailSender;
	@Autowired
	private SpringTemplateEngine templateEngine;

	// 메일 작성
	public void send(String who, String what) {
    		// 중략
	}

	// 타임리프 본문 구성
	public String setContext(String what) {
		Context context = new Context();
		context.setVariable("what", what);
		return templateEngine.process("tlTemplate", context);
	}

	// 메일 발송
	public void sendEmail(MailSenderDTO mailDTO) {
    		// 중략
	}
}

service : sendEmail

MimeMessage과 MimeMessageHelper를 사용하여 이메일의 수신자, 발신자, 제목, 내용 등을 설정한다.
setText 의 두번째 파라미터 -> true : MultiPartFiles 포함 / false : 미포함
javaMailSender를 사용하여 이메일을 발송한다.
try-catch블록 : 메일 발송 정보가 부족한 경우, SMTP서버에 연결할수 없는 경우 등, JavaMailSender에서 MessagingException이 발송할 수 있음.

package com.spingblog.cases.mailSender;
//중략
@Service
public class MailSenderService {
//중략
	// 메일 작성
	public void send(String who, String what) {
			//중략
	}
	// 타임리프 본문 구성
	public String setContext(String what) {
			//중략
	}

	// 메일 발송
	public void sendEmail(MailSenderDTO mailDTO) {
		MimeMessage mimeMessage = javaMailSender.createMimeMessage();
		try {
			MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, false, "UTF-8");
			mimeMessageHelper.setTo(mailDTO.getReceiver());
			mimeMessageHelper.setFrom(mailDTO.getSender());
			mimeMessageHelper.setSubject(mailDTO.getSubject());
			mimeMessageHelper.setText(mailDTO.getContext(), true);
			javaMailSender.send(mimeMessage);
		} catch (MessagingException e) {
			e.printStackTrace();
		}
	}
}

템플릿 html 파일

- 파일경로 : application.yml 파일에서 정의한 위치에 저장한다.
* src/main/resources/templates 하위에 위치하는 것이 일반적이며, 필요에 따라 설정하면 된다.
- 이메일 클라이언트는 css파일을 지원하지 않으므로, css를 인라인 스타일로 작성한다.
- context 변수가 치환되는 위치는 th:text="${변수명}" 이 위치해 있는 태그 안이다.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional //EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.thymeleaf.org">
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
	<title></title>
</head>
<body>
	<div id="wrap" style="width:auto; height:auto; margin:auto; font-family: SUITE Variable; background: #ffffff; font-size: 24px; overflow:auto;">
        <div class="my-5" style="text-align:center;">
			<div class="f-content" style="font-size: 16px; letter-spacing: 6px;">새로운 메일이 왔어요.</div>
			<div class="f-title font-weight-bold" style="font-size: 22px; letter-spacing: 3px;">기발자</div>
		</div>
        <hr>
        <div class="f-content ml-3" style="font-size: 15px; letter-spacing: 3px; margin: 10px; padding-top: 10px; text-align: center;">
            <br>
            <div style="text-align: center;">아래의 메세지를 확인해 주세요</div>
        </div>
        <div class="m-3" >
            <div class="text-center m-3" style="padding-top: 10px; display: flex; justify-content: center; align-items: center;">새로운 메세지</div>
            <div style="padding-top: 10px; display: flex; justify-content: center; align-items: center;">
                <div class="bg-secondary text-center p-3 f-title" style="font-size: 30px; letter-spacing: 6px; width: 300px; height: 80px; display: flex; justify-content: center; align-items: center; background-color: #666666; border-radius: 10px;">
                   <div th:text="${what}" style=" color:rgb(255, 255, 255); font-weight: bolder; text-align:center; align-items: center;"></div>
                </div>
            </div>
        </div>
        <div class="f-content ml-3" style="font-size: 15px; letter-spacing: 3px; margin: 10px; padding-top: 10px;">감사합니다.</div>
	
        <div class="f-small" style="font-size: 12px;">
            <br><br>
            <hr>
            <div>※ 본 메일은 발송전용 메일로, 회신하실 수 없습니다.</div>
        </div>

        <footer class="mt-3 pb-2" style="color: #666666;">
            <hr>
            <div style="font-size: 12px; text-align: center;" class="f-small text-center">ⓒ IAMCASTER 2023. All Rights Reserved.</div>
        </footer>
    </div>
</body>
</html>

발송 예시

위의 예시코드를 작동 시키고, 아래 대로 Get을 호출해 보자.
localhost:8080/send?who=abc@abc.com&what=Hello 안녕하세요

이렇게 발송된 메일을 확인하면 완료이다.

AWS RDS 환경설정 하기

kibal.countinue — Wed, 1 Nov 2023 16:45:28 +0900

기존에는 EC2 인스턴스에 MySQL을 함께 올려 사용했었다.

다만 서비스를 운영하다 보니, 성능저하가 빈번하게 발생했고, 자바 애플리케이션과 mysql 중 어느 부분이 성능저하를 만들어 내고 있는가 에 대한 직관적인 확인이 어려웠다.

따라서, EC2 와 RDS 를 분리하여 각각 인스턴스에 대한 관리를 용이하게 하고 싶었고, RDS를 추가하게 되었다.

RDS 생성 및 EC2 연결 방법은 아래와 같다.

RDS 인스턴스 생성하기

AWS RDS 에서 "데이터베이스 생성" 을 클릭, 아래의 화면으로 들어가며 시작된다.

데이터베이스 생성 방식 선택 은 표준 생성으로 둔다.

엔진 유형과 엔진 버전은 프로젝트에 적용되어 있는 DB를 선택하면 된다. 나의 경우, MySQL 8.0이 적용되어 있다.

템플릿은 필요에 따라 선택하게 되는데, 무료 사용을 위해 프리 티어를 선택했다.

DB 인스턴스 식별자는 이 인스턴스를 내가 구분할 수 있는 텍스트로 잘 지어주자.
마스터 사용자 이름과 마스터 암호는 db 로그인 시 사용되는 이름으로, 프로젝트설정값을 변경하고 싶지 않다면 맞추어 변경하면 된다.

인스턴스 구성과 스토리지는 필요 조건에 따라 설정하면 되는데, 난 기본값에서 변경하지 않았다.

연결 은 잘 알아두는 것이 좋다.
기존에 EC2인스턴스를 생성해 놓은 경우, EC2 컴퓨팅 리소스에 연결 을 선택하면 VPC 환경을 해당 EC2 인스턴스로 잡아준다. 다만 이 경우, 로컬에서의 접속은 불가능하나, EC2 인스턴스에서 db client 로 접속할 수 있다.

EC2 인스턴스는 적용할 EC2 인스턴스를 선택해 주면 된다.

VPC 보안 그룹을 기존 항목 선택 하여, EC2 생성 시 만들어놓은 보안그룹과 같은 적용을 받도록 할 수 있다.
추가VPC 보안 그룹 에서 EC2와 같은 보안그룹을 선택하면 된다.

추가구성 을 클릭하면 포트번호를 선택할 수 있다. MySQL 기본 포트번호인 3306을 그대로 사용했다.

데이터베이스 인증은 기본 암호인증을 사용할 것이다.

이제 데이터베이스 생성을 누르면 RDS 인스턴스가 생성된다.

VPC 보안그룹 확인하기

DB 인스턴스로 들어가서 보안그룹이 잘 묶여있는지 확인해 보자.

DB인스턴스를 생성할 때, EC2 리소스에 연결했으므로,
아래 화면과 같이 rds-ec2-1 라는 보안그룹이 생성된 것을 확인할 수 있다.

rds-ec2-1 보안그룹에 들어가서, 규칙이 어떻게 설정되어있는지 확인해 보자.

인바운드 규칙을 확인해 보니, sg-0f60~~ 라는 소스에 대해서 3306 포트에 인바운드 허용한 것을 확인할 수 있다.
저 보안그룹ID에서 발생된 트래픽만 접속이 허용되므로, 설정된 소스가 ec2의 보안그룹에 해당할 것이다.

그렇다면 EC2 인스턴스의 보안그룹을 확인해 보자.
보안그룹 을 보니 RDS 인스턴스에 접속이 허용된 보안그룹 ID가 EC2 인스턴스에도 적용되어 있는 것을 확인할 수 있다.

EC2 에서 RDS 접속해 보기

AWS 대시보드에서 할 환경 설정은 끝났다.

EC2 <> RDS 간 정상적인 통신이 가능한 지를 확인하기 위해, EC2에서 RDS 데이터베이스에 접속해 보자.
(EC2 에 DB 클라이언트가 설치되어 있지 않다면, EC2에 mysql client 설치하기 글을 확인하길 바란다.)
mysql -u <db사용자명> -p -h <호스트의 엔드포인트>
RDS 연결 및 보안에서 엔드포인트를 확인할 수 있다.

이제 EC2 인스턴스에서 RDS에 원격으로 접속할 수 있다.

EC2 (Amazon Linux 2023) 에 mysql 클라이언트 설치하기

kibal.countinue — Wed, 1 Nov 2023 16:36:40 +0900

RDS 의 데이터베이스 에 퀴리 실행, 테이블 확인 등을 하기 위해 EC2 에 mysql 을 설치해 볼 것이다.

1. MySQL 8.0 설치 패키지를 내려받는다. (rpm)

sudo dnf install https://dev.mysql.com/get/mysql80-community-release-el9-1.noarch.rpm
아마존 리눅스 2023 에서sms el9-1 버전의 리포지토리를 지원한다.

GPG key 등록하기

sudo rpm --import https://repo.mysql.com/RPM-GPG-KEY-mysql-2023

MySQL 클라이언트 설치

sudo dnf install mysql
mysql client 설치 완료

DB 접속해보기

mysql -u <db사용자명> -p -h <호스트의 엔드포인트>
RDS 인스턴스에 접속했다.

SpringBoot 에서 JPA 사용하기 - 활용 하기

kibal.countinue — Tue, 31 Oct 2023 23:50:33 +0900

이전 글: JPA 환경설정 하기

SpringBoot 에서 JPA 사용하기 - 환경설정 하기

Lombok 설치하기 Lombok을 설치하면 별도의 getter/setter 을 만들지 않아도, 어노테이션으로 간단히 객체를 다룰 수 있다. JPA 는 DB 상의 데이터를 객체처럼 다룰 수 있는 핵심 장점이 있는데, Lombok은 그

joelinseoul.tistory.com

조회할 메소드를 JPQL 문법에 맞추어 메소드로 작성하면, 설정된 데이터베이스에 맞는 쿼리를 조회하여 결과를 리턴해준다.

JPA 가 제공하는 메소드는 아래와 같다.

조회하기

JPA 가 제공하는 조회 메소드는 아래 표와 같다.

메소드 명 설명 리턴 예시

findAll() 모든 행 조회 List<객체> findAll();

findBy컬럼명() 컬럼값으로 조회 List<객체> 혹은 객체 findByName("홍길동");

countBy컬럼명() 컬럼값에 일치하는 개수 조회 long countByUID(1);

orderBy컬럼명() 결과 정렬 List<객체> OrderByNameDesc();

existsBy컬럼명() 데이터 존재 여부 boolean existsByUID(1);

위의 조회 메소드 표 상 메소드에 아래의 키워드를 추가할 수 있다.

keyword 설명 예시

And 여러 컬럼값과 일치하는 행 And 조회 findByNameAndEmail(name, email)

Or 여러 컬럼값과 일치하는 행 Or 조회 findByNameOrEmail(name, email)

Contains, Containing Like '%키워드%' findBySubjectContaining("키워드")

Like like '키워드'
키워드와 일치하는 것만 가져오므로 주의 findBySubjectLike("키워드")

StartingWith like '키워드%' findByStartingWith("키워드")

Between 특정값 이상~이하 조회 findByAgeBetween(20, 25)
20 ~ 25 조회됨

In in문으로 일치하는 값 모두 조회
select * from 테이블 where name in ('길동', '춘향'); findByNameIn(names)
여기서 names는 List<String>

Top Limit 제한 개수 한 개만 가져올 때:findTop()
5개 가져올 때:findTop5ByOrderByNameDesc()
※Top5 뒤에 By가 없으면 에러 발생

builder 패턴과 함께 사용하기

JPA 가 CRUD 하는 단위는 객체 이다.
따라서 lombok의 builder를 활용하여 코드를 간소화 시킬 수 있다.

@RestController
public class UserInfoController {
	@Autowired
	private UserInfoRepository userInfoRepository;
	@GetMapping("/")
	public String hello() {
		UserInfo newUser = userInfoRepository.save(UserInfo.builder()
				.name("홍길동")
				.email("hong@gil.dong")
				.build()
				);
		return newUser.toString();
	}
}

CRUD 예시

JPA 에서의 CRUD 를 경험하기 위해, 아래의 예시코드를 작성해 보았다.

package com.spingblog.cases.userinfo;

import java.time.LocalDateTime;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import com.spingblog.cases.userinfo.domain.UserInfo;
import com.spingblog.cases.userinfo.repository.UserInfoRepository;

@RestController
public class UserInfoController {
	@Autowired
	private UserInfoRepository userInfoRepository;
	@GetMapping("/")
	public List<UserInfo> hello() {
		//생성 : 홍길동을 등록해라
		for(int i = 0; i < 2; i++) {
			userInfoRepository.save(UserInfo.builder()
					.name("홍길동")
					.email("hong@gil.dong")
					.build()
					);
		}
		
		//읽기 : 홍길동이 몇명인지 찾아라
		long countHong = userInfoRepository.countByNameLike("홍길동");
		//읽기 : 홍길동을 모두 조회하라
		List<UserInfo> findHongs = userInfoRepository.findByNameLike("홍길동");
		
        //업데이트 : 홍길동이 한명이 아니면, 기존 홍길동의 이름을 성춘향으로 수정하라
		if(countHong > 1) {
			UserInfo oldHong = findHongs.get(0);
			oldHong = oldHong.toBuilder()
					.name("성춘향")
					.email("sung@chun.hyang")
					.updatedAt(LocalDateTime.now())
					.build();
			userInfoRepository.save(oldHong);
		}
		
		//삭제 : 이름에 춘 이 들어가면 삭제하라
		List<UserInfo> findChun = userInfoRepository.findByNameContaining("춘");
		userInfoRepository.deleteAll(findChun);

		//읽기 : 남은 회원 중 가장 최큰에 가입한 2명을 출력하라
		List<UserInfo> findLatest2 = userInfoRepository.findTop2ByOrderByIdDesc();

		return findLatest2;
	}
}

위 코드 실행에 따라, 발생된 쿼리는 아래와 같다.

Hibernate: 
    insert 
    into
        userinfo
        (createdAt, email, name, updatedAt) 
    values
        (?, ?, ?, ?)
 [2m2023-10-31 18:47:51.922 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745671922 | took 5ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
insert into userinfo (createdAt, email, name, updatedAt) values (?, ?, ?, ?)
insert into userinfo (createdAt, email, name, updatedAt) values ('2023-10-31T18:47:51.895+0900', 'hong@gil.dong', '홍길동', '2023-10-31T18:47:51.895+0900');
 [2m2023-10-31 18:47:51.954 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745671954 | took 2ms | commit | connection 1| url jdbc:mysql://localhost:3306/springbootblog

;
Hibernate: 
    insert 
    into
        userinfo
        (createdAt, email, name, updatedAt) 
    values
        (?, ?, ?, ?)
 [2m2023-10-31 18:47:51.958 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745671958 | took 1ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
insert into userinfo (createdAt, email, name, updatedAt) values (?, ?, ?, ?)
insert into userinfo (createdAt, email, name, updatedAt) values ('2023-10-31T18:47:51.956+0900', 'hong@gil.dong', '홍길동', '2023-10-31T18:47:51.956+0900');
 [2m2023-10-31 18:47:51.962 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745671962 | took 1ms | commit | connection 1| url jdbc:mysql://localhost:3306/springbootblog

;
Hibernate: 
    select
        count(userinfo0_.id) as col_0_0_ 
    from
        userinfo userinfo0_ 
    where
        userinfo0_.name like ? escape ?
 [2m2023-10-31 18:47:52.069 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672069 | took 3ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
select count(userinfo0_.id) as col_0_0_ from userinfo userinfo0_ where userinfo0_.name like ? escape ?
select count(userinfo0_.id) as col_0_0_ from userinfo userinfo0_ where userinfo0_.name like '홍길동' escape '\';
Hibernate: 
    select
        userinfo0_.id as id1_0_,
        userinfo0_.createdAt as createda2_0_,
        userinfo0_.email as email3_0_,
        userinfo0_.name as name4_0_,
        userinfo0_.updatedAt as updateda5_0_ 
    from
        userinfo userinfo0_ 
    where
        userinfo0_.name like ? escape ?
 [2m2023-10-31 18:47:52.078 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672078 | took 1ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ where userinfo0_.name like ? escape ?
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ where userinfo0_.name like '홍길동' escape '\';
 [2m2023-10-31 18:47:52.090 [0;39m  [33m WARN [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mo.h.p.entity.AbstractEntityPersister     [0;39m  [2m: [0;39m HHH000502: The [createdAt] property of the [com.spingblog.cases.userinfo.domain.UserInfo] entity was modified, but it won't be updated because the property is immutable.
Hibernate: 
    update
        userinfo 
    set
        email=?,
        name=?,
        updatedAt=? 
    where
        id=?
 [2m2023-10-31 18:47:52.099 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672099 | took 1ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
update userinfo set email=?, name=?, updatedAt=? where id=?
update userinfo set email='sung@chun.hyang', name='성춘향', updatedAt='2023-10-31T18:47:52.090+0900' where id=12;
 [2m2023-10-31 18:47:52.113 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672113 | took 12ms | commit | connection 1| url jdbc:mysql://localhost:3306/springbootblog

;
Hibernate: 
    select
        userinfo0_.id as id1_0_,
        userinfo0_.createdAt as createda2_0_,
        userinfo0_.email as email3_0_,
        userinfo0_.name as name4_0_,
        userinfo0_.updatedAt as updateda5_0_ 
    from
        userinfo userinfo0_ 
    where
        userinfo0_.name like ? escape ?
 [2m2023-10-31 18:47:52.118 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672118 | took 1ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ where userinfo0_.name like ? escape ?
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ where userinfo0_.name like '%춘%' escape '\';
Hibernate: 
    delete 
    from
        userinfo 
    where
        id=?
 [2m2023-10-31 18:47:52.124 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672124 | took 1ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
delete from userinfo where id=?
delete from userinfo where id=12;
 [2m2023-10-31 18:47:52.127 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672127 | took 2ms | commit | connection 1| url jdbc:mysql://localhost:3306/springbootblog

;
Hibernate: 
    select
        userinfo0_.id as id1_0_,
        userinfo0_.createdAt as createda2_0_,
        userinfo0_.email as email3_0_,
        userinfo0_.name as name4_0_,
        userinfo0_.updatedAt as updateda5_0_ 
    from
        userinfo userinfo0_ 
    order by
        userinfo0_.id desc limit ?
 [2m2023-10-31 18:47:52.133 [0;39m  [32m INFO [0;39m  [35m12384 [0;39m  [2m--- [0;39m  [2m[nio-8080-exec-1] [0;39m  [36mp6spy                                    [0;39m  [2m: [0;39m #1698745672133 | took 0ms | statement | connection 1| url jdbc:mysql://localhost:3306/springbootblog
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ order by userinfo0_.id desc limit ?
select userinfo0_.id as id1_0_, userinfo0_.createdAt as createda2_0_, userinfo0_.email as email3_0_, userinfo0_.name as name4_0_, userinfo0_.updatedAt as updateda5_0_ from userinfo userinfo0_ order by userinfo0_.id desc limit 2;

위 예시코드에 따라 실행 후 결과

JPA 네이티브 쿼리

위와 같이 JPA는 일상적인 조회에서 코드를 간결하고 객체에 집중할 수 있도록 도와주는 강력한 메소드들을 가지고 있다.
다만 데이터베이스의 특정 기능을 활용해야 하는 경우 등에서는 JPA 네이티브 쿼리를 활용할 수 있다.

아래, mysql 의 regexp 기능을 활용하고자 할 때 JPA Native Query 를 활용한 예시이다.
repository 에서 native query를 활용할 메서드를 작성 후, @Query 어노테이션을 추가하면 된다.
@Query 의 파라미터는 아래와 같다.
- value : 쿼리 문자열을 지정하는 파라미터. SQL 문법에 맞추어 작성함.
- nativeQuery : 기본값은 false 이며, true 로 입력 시 value 에 작성한 텍스트를 쿼리로 사용.
@Repository
public interface UserInfoRepository extends JpaRepository<UserInfo, Integer> {
	@Query(value="SELECT * FROM userinfo WHERE email REGEXP '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'", nativeQuery = true)
	public List<UserInfo> findValidEmail();
}
네이티브 쿼리를 적용한 메소드

위의 메소드를 동작시키면 아래의 로그와 같이, value 값이 그대로 쿼리로 사용된 것을 알 수 있다.
네이티브 쿼리 동작 로그

네이티브 쿼리 사용 시 한 가지 주의해야 할 점이 있다.
JPQL 의 장점은 DB를 변경하더라도, 변경된 DB에 맞추어 객체와 그 필드를 기준으로 쿼리를 작성한다는 것이 큰 장점인데, 네이티브 쿼리의 경우 DB에 종속적인 SQL 문법을 따르게 되며, DB변경 시 변경 된 DB에 맞춘 문법으로 수정해야 한다.
따라서 네이티브 쿼리 보다는 myBatis 를 함께 사용 하는 것이 나을 것이다.

SpringBoot 에서 JPA 사용하기 - 환경설정 하기

kibal.countinue — Tue, 31 Oct 2023 17:13:23 +0900

Lombok 설치하기

Lombok을 설치하면 별도의 getter/setter 을 만들지 않아도, 어노테이션으로 간단히 객체를 다룰 수 있다.

JPA 는 DB 상의 데이터를 객체처럼 다룰 수 있는 핵심 장점이 있는데, Lombok은 그 장점을 더욱 돋보이게 해준다.

Lombok 설치는 아래 글에서 확인할 수 있다.

이클립스에 Lombok 설치하기

Lombok 은 객체지향 개발을 편리하게 해주는 라이브러리이다. Entity 클래스 에서 직접 Getter/Setter 를 만들 필요 없이, @Data 혹은 @Getter/@Setter 등의 어노테이션만 추가하면 객체를 편리하게 사용하게

joelinseoul.tistory.com

spring-boot-starter-data-jpa 의존성 추가

우선 그래들에 의존성을 추가한다.
build.gradle에서 스프링부트의 스타터 중 하나인 spring-boot-starter-data-jpa 의존성을 추가한다.

* build.gradle을 수정했다면 잊지말고 refresh gradle project 를 하길 바란다.
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

P6Spy 의존성 추가 (선택)

P6Spy 는 JDBC 드라이버의 프록시로 작동하여 SQL 쿼리를 가로채서 로깅하는 라이브러리다.
이 의존성을 추가하면 콘솔을 통해 쿼리 결과를 실시간으로 볼 수 있다.
필요 여부에 따라 추가하면 된다. (성능에 영향을 주기 때문에)
	implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.5.7'
이를 추가하면, 아래와 같이 콘솔에서 쿼리 처리 결과를 확인할 수 있다.

application.yml 수정하기

최소 동작을 위한 필수 설정은 끝났다.
이제 좀더 유연하고 편하게 JPA 를 즐길 수 있도록, application.yml 을 설정한다.

나의 default 설정값은 아래와 같다.
spring:
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true
    hibernate:
      naming:
        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
      ddl-auto: none
위 설정의 내용은 key에 따른 옵션 별 내용을 담은 아래 표를 참고하길 바란다.

key option

spring.jpa.show-sql true: JPA 쿼리문 확인 가능

spring.jpa.hibernate.ddl-auto create:기존 테이블을 삭제 후 새로 생성
create-drop:기존 테이블을 삭제 후 새로 생성 + 종료 후 다시 drop
(drop + create + drop)
update:테이블과 매핑 정보 비교 후 변경사항만 수정(만약 기존 테이블 없으면 create)
validate:차이가 있으면 경고를 날린 후 수행하지 않음
none:테이블 자동 생성기능 사용 안함(있는 테이블로 사용)

spring.jpa.properties.hibernate.format_sql true: jpa 구현체인 하이버네이트 동적쿼리 로그를 예쁘게 출력

spring.jpa.hibernate.naming.implicit-strategy 설정 시 객체 명과 테이블 명이 같을 경우 해당 객체명을 테이블명으로 사용.
org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl

spring.jpa.hibernate.naming.physical-strategy 설정 시 테이블 명이나 컬럼 명을 변환하지 않고 그대로 사용함.
(카멜케이스인 컬럼명을 사용할 수 있음.)
org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

객체 설정 방법

JPA 는 객체 단위의 DB 처리를 하므로, 객체마다 JPA가 인식할 수 있도록 설정하는 것이 필요하다.

우선 간단한 예시를 들자면 아래와 같다.
@Entity						 // jpa가 인식할 수 있도록 선언
@ToString					 // 객체 변수 값을 문자열로 반호나해서 객체의 상태를 쉽게 확인.
@Builder(toBuilder = true)	 // 객체 생성/수정 등을 할 수 있도록 빌더 패턴 생성.
@NoArgsConstructor			 // 매개변수가 없는 기본 생성자를 생성.
@AllArgsConstructor			 // 전체 생성자 생성
@Table(name = "userinfo")	 //테이블 명 매핑
@Data						 //Getter 및 Setter 자동 생성
public class UserInfo {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	private String name;
	private String email;
	@UpdateTimestamp
	@Column(name="createdAt", updatable=false)
	private LocalDateTime createdAt;
	@UpdateTimestamp
	@Column(name="updatedAt")
	private LocalDateTime updatedAt;
	
}
아래는 javax.persistence 라이브러리에 포함되는 어노테이션이다.

어노테이션 설명

@Entity 해당 클래스를 JPA 엔티티로 선언.

@Table 해당 객체와 매핑시킬 DB 상의 테이블 이름 설정.
미작성 시 클래스 이름이 테이블 명으로 설정됨.
* 파라미터
- name : 매핑시킬 테이블명

@Column 객체의 변수와 매핑될 DB상의 컬럼 이름 설정.
미작성 시 변수 이름이 컬럼 명으로 설정됨.
(변수 명이 카멜케이스로 작성 되었다면 Column 설정 필수)
* 파라미터
- name : 매핑시킬 컬럼명
- updatable : 수정 가능 여부

@Id 객체의 Primary Key 선언.

@GeneratedValue Primary Key의 생성 방법 설정.
* 파라미터
- strategy=GenerationType.IDENTITY : auto increment 와 같음.

@UpdateTimestamp rdb query 상 DEFAULT CURRENT_TIMESTAMP 와 같음.

Repository 에서 JpaRepository extends 하기

MVC 패턴으로 작성된 애플리케이션이라면 객체에 따른 Repository 인터페이스가 있을 것이다.
없다면 해당 객체를 다룰 수 있는 repository를 만들고, repository 에 JpaRepository 를 extends 해야 한다.

아래는 위의 UserInfo 객체 예시에 해당하는 Repository 이다.
이 인터페이스는 JpaRepository를 상속받으며, 객체의 타입과 ID 타입을 선언해야 한다.
@Repository
public interface UserInfoRepository extends JpaRepository<UserInfo, Integer> {

}

JPA 사용 준비 완료

여기까지 설정을 완료하면, 이제 사용하면 된다.

정상적으로 동작하는지 확인을 위해 로컬서버를 켜보자.

스프링부트가 정상적으로 켜지면 우선 설정을 완료했다고 생각할 수 있다.

다음 글 : JPA 활용하기

SpringBoot 에서 JPA 사용하기 - 활용 하기

이전 글: JPA 환경설정 하기 SpringBoot 에서 JPA 사용하기 - 환경설정 하기 Lombok 설치하기 Lombok을 설치하면 별도의 getter/setter 을 만들지 않아도, 어노테이션으로 간단히 객체를 다룰 수 있다. JPA 는 DB

joelinseoul.tistory.com

이클립스에 Lombok 설치하기

kibal.countinue — Tue, 31 Oct 2023 15:39:04 +0900

Lombok 라이브러리는 객체지향 개발을 편리하게 해준다.

Entity 클래스 에서 직접 Getter/Setter 를 만들 필요 없이, @Data 혹은 @Getter/@Setter 등의 어노테이션만 추가하면

객체를 편리하게 사용하게 해준다.

본 설명은 아래의 환경 기준이다..

- 이클립스 (STS)

- 윈도우

- gradle

Lombok.jar 다운받기

아래 URL에서 Lombok을 다운받는다.
https://projectlombok.org/downloads/lombok.jar

Lombok.jar 설치하기

위에서 다운받은 Lombok을 열면 아래의 설치화면이 나온다.
설치 프로그램에서 자동으로 IDE 리스트를 보여주는데, 여기서 각자 적용할 IDE 를 선택해 주면 된다.

※ 주의사항
lombok.jar 의 위치가 한글 폴더로 되어있으면 안된다!

혹시 STS 와 같은 IDE를 설치하지 않고 사용하는 경우에는, Specify location을 클릭해, 아래 화면에서 선택할 수 있다. STS 실행파일이 있는 경로의 폴더를 선택해 주면 된다.

Install Successful 화면이 나오면 IDE 경로로 들어가 Lombok 파일이 생성되었는지 확인해 보자.

build.gradle에 Lombok 의존성 추가하기

이제 IDE로 돌아와, build.gradle 에 아래 두개의 의존성을 추가한다.
	compileOnly 'org.projectlombok:lombok'
	annotationProcessor 'org.projectlombok:lombok'
* build.gradle을 수정했다면 잊지말고 refresh gradle project 를 하길 바란다.

Lombok 동작 확인

먼저 프로젝트를 Clean 한다.
(상단 메뉴 바 > Project > Clean)

이제 Entity 객체에 @Data, @Getter 등을 추가하고, getter가 동작하는지 확인하면 정상동작 까지 확인완료.
UserInfo 객체에 @Data 어노테이션 작성

이제 UserInfo 객체에서 getName으로 name을 받아올 수 있다.

메소드	설명
apiInfo(ApiInfo apiInfo)	API의 메타데이터를 설정. (제목, 설명, 버전 등)
groupName(String groupName)	API 문서의 그룹 이름을 설정.
select()	`ApiSelectorBuilder`를 반환하여, API를 선택하고 세부 사항을 설정.
enable(boolean enabled)	Swagger를 활성화하거나 비활성화.
protocols(Set<String> protocols)	지원하는 프로토콜을 설정. (예: "http", "https")
host(String host)	API 문서에 사용할 호스트 이름을 설정.
directModelSubstitute(Class<?> originalClass, Class<?> substituteClass)	특정 클래스를 다른 클래스로 대체. (모델 대체)
alternateTypeRules(AlternateTypeRules alternateTypeRules)	주어진 타입 규칙에 따라 모델을 변경.
useDefaultResponseMessages(boolean useDefaultResponseMessages)	기본 응답 메시지 사용 여부를 설정.
globalResponseMessage(RequestMethod method, List<ResponseMessage> responseMessages)	특정 HTTP 메소드에 대한 전역 응답 메시지를 설정.
securitySchemes(List<? extends SecurityScheme> securitySchemes)	보안 스키마를 설정. (예: API 키, OAuth2)
securityContexts(List<SecurityContext> securityContext)	보안 컨텍스트를 설정.
tags(Tag tags)	API 문서에 사용할 태그를 설정.
pathMapping(String path)	기본 경로 매핑을 설정.

메소드 명	설명	리턴	예시
findAll()	모든 행 조회	List<객체>	findAll();
findBy컬럼명()	컬럼값으로 조회	List<객체> 혹은 객체	findByName("홍길동");
countBy컬럼명()	컬럼값에 일치하는 개수 조회	long	countByUID(1);
orderBy컬럼명()	결과 정렬	List<객체>	OrderByNameDesc();
existsBy컬럼명()	데이터 존재 여부	boolean	existsByUID(1);

keyword	설명	예시
And	여러 컬럼값과 일치하는 행 And 조회	findByNameAndEmail(name, email)
Or	여러 컬럼값과 일치하는 행 Or 조회	findByNameOrEmail(name, email)
Contains, Containing	Like '%키워드%'	findBySubjectContaining("키워드")
Like	like '키워드' 키워드와 일치하는 것만 가져오므로 주의	findBySubjectLike("키워드")
StartingWith like	'키워드%'	findByStartingWith("키워드")
Between	특정값 이상~이하 조회	findByAgeBetween(20, 25) 20 ~ 25 조회됨
In	in문으로 일치하는 값 모두 조회 select * from 테이블 where name in ('길동', '춘향');	findByNameIn(names) 여기서 names는 List<String>
Top	Limit 제한 개수	한 개만 가져올 때:findTop() 5개 가져올 때:findTop5ByOrderByNameDesc() ※Top5 뒤에 By가 없으면 에러 발생

key	option
spring.jpa.show-sql	true: JPA 쿼리문 확인 가능
spring.jpa.hibernate.ddl-auto	create:기존 테이블을 삭제 후 새로 생성 create-drop:기존 테이블을 삭제 후 새로 생성 + 종료 후 다시 drop (drop + create + drop) update:테이블과 매핑 정보 비교 후 변경사항만 수정(만약 기존 테이블 없으면 create) validate:차이가 있으면 경고를 날린 후 수행하지 않음 none:테이블 자동 생성기능 사용 안함(있는 테이블로 사용)
spring.jpa.properties.hibernate.format_sql	true: jpa 구현체인 하이버네이트 동적쿼리 로그를 예쁘게 출력
spring.jpa.hibernate.naming.implicit-strategy	설정 시 객체 명과 테이블 명이 같을 경우 해당 객체명을 테이블명으로 사용. org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl
spring.jpa.hibernate.naming.physical-strategy	설정 시 테이블 명이나 컬럼 명을 변환하지 않고 그대로 사용함. (카멜케이스인 컬럼명을 사용할 수 있음.) org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

어노테이션	설명
@Entity	해당 클래스를 JPA 엔티티로 선언.
@Table	해당 객체와 매핑시킬 DB 상의 테이블 이름 설정. 미작성 시 클래스 이름이 테이블 명으로 설정됨. * 파라미터 - name : 매핑시킬 테이블명
@Column	객체의 변수와 매핑될 DB상의 컬럼 이름 설정. 미작성 시 변수 이름이 컬럼 명으로 설정됨. (변수 명이 카멜케이스로 작성 되었다면 Column 설정 필수) * 파라미터 - name : 매핑시킬 컬럼명 - updatable : 수정 가능 여부
@Id	객체의 Primary Key 선언.
@GeneratedValue	Primary Key의 생성 방법 설정. * 파라미터 - strategy=GenerationType.IDENTITY : auto increment 와 같음.
@UpdateTimestamp	rdb query 상 DEFAULT CURRENT_TIMESTAMP 와 같음.