[Springboot] 16 리팩토링 마무리, 더티체킹, AOP

앞으로 계획

1. v1 단순히 nativeQuery CRUD 패턴구조

2. V2 마무리
• ORM
• JPQL (Java Persistence Query Language) - select 랑 조인 해봄!!
• 인증 (session) - 나중에 변경예정
• Exception 컨트롤러
• 서비스 레이어
• OpenInView(Lazy Loading) - Eager을 쓰면 알수 없는 에러가 날 수있어서 Lazy를 쓰는게 좋다. 레이지는 서비스단에서 마무리하기
• Static DTO
• 유효성 검사

3. 프로젝트 & Git 협업방법

4. 주제정하기&화면설계서. 기획자가 피그마로 다 만들어줌

5. HTML 디자인 수업

6. V3 시작 (동시)
• 양방향 매핑
• 복잡한 쿼리(NativeQuery → QLRM 라이브러리)
• 복잡한 쿼리(JQPL 썼을때 동일하게 안나오면 → 매핑하는 법 배울 예정)
• 동적 쿼리(매개변수에 의해서 쿼리가 달라지는 것)
• OAUTH2.0
⇒ 여기까지 배우면 프로젝트를 할 수 있다.

7. 테이블 설계 (동시) - 화면나오면 검사받고 테이블 만드는거 검사받기

8. 프로젝트 진행(9.24일)

9. 수업
• RestAPI 수업
• JWT 인증 방식
• Stream API
• 통합테스트
• API 문서
• flutter 수업
• 두번째 프로젝트 (이력서, 면접 준비) (9.25 시작예정!)

BoardService

BoardController

BoardController

BoardRequest

BoardController

더티체킹

더티 체킹 (Dirty Checking)이란?

Spring Data Jpa와 같은 ORM 구현체를 사용하다보면 더티 체킹이란 단어를 종종 듣게 됩니다. 더티 체킹이란 단어를 처음 듣는분들을 몇번 만나게 되어 이번 시간엔 더티 체킹이 무엇인지 알아보겠습니다. 모든 코드는 Github에 있습니다. 예를 들어 다음과 같은 코드가 있습니다. (Spring Data Jpa가 익숙하시겠지만, 네이티브한 코드 먼저 보고 가겠습니다.) @Slf4j @RequiredArgsConstructor @Service public class PayService { public void updateNative(Long id, String tradeNo) { EntityManager em = entityManagerFactory.createEntityManager(); Enti..

https://jojoldu.tistory.com/415

BoardService

OKKY - JPA 쿼리 캐싱문제

안녕하세요. 현재 Spring boot 와 Spring Data Jpa, QueryDsl 를 이용해 간단한 프로젝트를 만들고 있습니다. jpa의 1차 캐시 관련해서 질문드립니다.Spring Data Jpa 의 JpaRepository에서 기본으로 제공하는 findById 등을 사용하면 한 트랜잭션에서 같은 id로 몇번을 호출해도 쿼리가 한번만 날아가는데 j

https://okky.kr/questions/934020

유효성 검사

build.gradle

UserRequest

1. 아침먹기(젓가락)

2. 점심먹기(젓가락)

3. 저녁먹기(젓가락)

AOP

• Aspect 붙이기 → AOP로 등록

• 이전 이후를 다 관리할 수 있다.

1. 라이브러리 등록

implementation 'org.springframework.boot:spring-boot-starter-aop'

2. 어노테이션 만들기

package shop.mtcoding.blog.core;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Hello {
}

3. AOP 만들기

package shop.mtcoding.blog.core.error;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect // AOP 등록
public class GlobalValidationHandler {

    @Around("@annotation(shop.mtcoding.blog.core.Hello)")
    //@Before("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    public Object hello1(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("aop hello1 before 호출됨");
        Object proceed = jp.proceed(); // @Hello 어노테이션이 붙은 함수 호출 "user/login-form";
        System.out.println("aop hello1 after 호출됨");
        System.out.println(proceed);
        return proceed;
    }
}

4. 발동시키기

@Hello
@GetMapping("/login-form")
public String loginForm() {
    System.out.println("loginForm 호출됨");
    return "user/login-form";
}

package com.example.kakao.user;

import lombok.Getter;
import lombok.Setter;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import java.util.Collections;


public class UserRequest {

    @Getter
    @Setter
    public static class JoinDTO {

        @NotEmpty
        @Pattern(regexp = "^[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,6}$", message = "이메일 형식으로 작성해주세요")
        private String email;

        @NotEmpty
        @Size(min = 8, max = 20, message = "8에서 20자 이내여야 합니다.")
        @Pattern(regexp = "^(?=.*[a-zA-Z])(?=.*\\d)(?=.*[@#$%^&+=!~`<>,./?;:'\"\\[\\]{}\\\\()|_-])\\S*$", message = "영문, 숫자, 특수문자가 포함되어야하고 공백이 포함될 수 없습니다.")
        private String password;

        @NotEmpty
        private String username;

        public User toEntity() {
            return User.builder()
                    .email(email)
                    .password(password)
                    .username(username)
                    .roles(Collections.singletonList("ROLE_USER"))
                    .build();
        }
    }

    @Getter
    @Setter
    public static class LoginDTO {
        @NotEmpty
        @Pattern(regexp = "^[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,6}$", message = "이메일 형식으로 작성해주세요")
        private String email;

        @NotEmpty
        @Size(min = 8, max = 20, message = "8에서 20자 이내여야 합니다.")
        @Pattern(regexp = "^(?=.*[a-zA-Z])(?=.*\\d)(?=.*[@#$%^&+=!~`<>,./?;:'\"\\[\\]{}\\\\()|_-])\\S*$", message = "영문, 숫자, 특수문자가 포함되어야하고 공백이 포함될 수 없습니다.")
        private String password;
    }

    @Getter
    @Setter
    public static class EmailCheckDTO {
        @NotEmpty
        @Pattern(regexp = "^[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,6}$", message = "이메일 형식으로 작성해주세요")
        private String email;
    }
}

package shop.mtcoding.blog.temp;

import org.junit.jupiter.api.Test;

import java.util.regex.Pattern;

// java.util.regex.Pattern
public class RegexTest {

    @Test
    public void 한글만된다_test() throws Exception {
        String value = "ㄱ";
        boolean result = Pattern.matches("^[가-힣]+$", value);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void 한글은안된다_test() throws Exception {
        String value = "abc";
        boolean result = Pattern.matches("^[^ㄱ-ㅎ가-힣]*$", value);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void 영어만된다_test() throws Exception {
        String value = "ssar";
        boolean result = Pattern.matches("^[a-zA-Z]+$", value);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void 영어는안된다_test() throws Exception {
        String value = "가22";
        boolean result = Pattern.matches("^[^a-zA-Z]*$", value);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void 영어와숫자만된다_test() throws Exception {
        String value = "ab12";
        boolean result = Pattern.matches("^[a-zA-Z0-9]+$", value);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void 영어만되고_길이는최소2최대4이다_test() throws Exception {
        String value = "ssar";
        boolean result = Pattern.matches("^[a-zA-Z]{2,4}$", value);
        System.out.println("테스트 : " + result);
    }

    // username, email, fullname
    @Test
    public void user_username_test() throws Exception {
        String username = "ssar";
        boolean result = Pattern.matches("^[a-zA-Z0-9]{2,20}$", username);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void user_fullname_test() throws Exception {
        String fullname = "메타코딩";
        boolean result = Pattern.matches("^[a-zA-Z가-힣]{1,20}$", fullname);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void user_email_test() throws Exception {
        String fullname = "ssaraa@nate.com"; // ac.kr co.kr or.kr
        boolean result = Pattern.matches("^[a-zA-Z0-9]{2,10}@[a-zA-Z0-9]{2,6}\\.[a-zA-Z]{2,3}$", fullname);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void account_gubun_test1() throws Exception {
        String gubun = "DEPOSIT"; // ac.kr co.kr or.kr
        boolean result = Pattern.matches("^(DEPOSIT)$", gubun);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void account_gubun_test2() throws Exception {
        String gubun = "TRANSFER"; // ac.kr co.kr or.kr
        boolean result = Pattern.matches("^(DEPOSIT|TRANSFER)$", gubun);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void account_tel_test1() throws Exception {
        String tel = "010-3333-7777"; // ac.kr co.kr or.kr
        boolean result = Pattern.matches("^[0-9]{3}-[0-9]{4}-[0-9]{4}", tel);
        System.out.println("테스트 : " + result);
    }

    @Test
    public void account_tel_test2() throws Exception {
        String tel = "01033337777"; // ac.kr co.kr or.kr
        boolean result = Pattern.matches("^[0-9]{11}", tel);
        System.out.println("테스트 : " + result);
    }
}

UserRequest

ChatGPT의 말:

1. @NotEmpty

• 대상: String, Collection, Map, 또는 Array와 같은 빈 상태를 가질 수 있는 객체.

• 검사 조건: null이 아니고, 비어 있지 않음을 검사합니다.

• 적용 예시: 이 어노테이션은 문자열이 비어 있지 않거나, 컬렉션이 최소한 하나의 요소를 가지고 있는지 확인하는 데 사용됩니다.
• 빈 문자열 ""은 실패 (유효성 검사에 통과하지 않음).
• null 값은 실패.
• 공백 문자열 " "는 통과 (공백도 비어있지 않으므로 통과).

java코드 복사
@NotEmpty
private String name;

2. @NotBlank

• 대상: String 데이터.

• 검사 조건: null이 아니고, 비어 있지 않으며, 공백으로만 이루어지지 않음을 검사합니다.

• 적용 예시: 이 어노테이션은 문자열이 비어 있지 않고, 단순히 공백 문자로만 이루어져 있지 않은지 확인하는 데 사용됩니다.
• 빈 문자열 ""은 실패.
• null 값은 실패.
• 공백 문자열 " "도 실패 (공백만 있는 문자열은 비어있는 것으로 간주).

java코드 복사
@NotBlank
private String username;

주요 차이점 요약:

• @NotEmpty: null이나 빈 문자열/컬렉션은 허용하지 않지만, 공백만 있는 문자열은 허용됩니다.

• @NotBlank: null이나 빈 문자열뿐만 아니라 공백만 있는 문자열도 허용하지 않습니다.

예시 비교:

java코드 복사
@NotEmpty
private String description; // null, ""은 허용되지 않지만, " "는 허용됩니다.

@NotBlank
private String username; // null, "", " " 모두 허용되지 않습니다.

• @Valid DTO 와 Errors 쓸때는 붙여서 써야한다. 중간에 파라미터 오면 Errors로 전달안됨!!

• 요청(Request) dto (→ BoardRequest, UserRequset ) 에 다 NotEmpty 적어주기

• NotEmpty에 message를 줘서 내가 원하는 문구로 알릴 수 있는데 기본 문구가 잘 되어있으니

BoardRequest

package shop.mtcoding.blog.board;

import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import shop.mtcoding.blog.user.User;

public class BoardRequest {

    // 요청DTO는 동일하게 생겨도 중복해서 만들기
    @Data
    public static class UpdateDTO { // title, content 2개만 담으면 된다.
        @NotEmpty
        private String title;
        @NotEmpty
        private String content;

        // insert 가 아니라 UPDATE 이니까 투엔티티 없어도 댐

    }

    @Data
    public static class SaveDTO { // title, content 2개만 담으면 된다.
        //@Pattern(regexp = ) 정규표현식 패턴
        @NotEmpty
        private String title;
        @NotEmpty(message = "비워놓지마. (근데 이거 안써줘도 됨)")
        private String content;

        // insert 할 때는 toEntity 를 만든다.
        public Board toEntity(User sessionUser) { // 날짜는 엔티티에 @CreationTimeStamp 붙여주면 자동으로 들어간다.
            return Board.builder()
                    .title(title)
                    .content(content)
                    .user(sessionUser)
                    .build(); // shift + enter
        }

    }


}

UserRequest

package shop.mtcoding.blog.user;

import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
import lombok.Data;

// 내부클래스로 관리!!
// 이렇게 하면 위험하지 않음
public class UserRequest {
    @Data // getter, setter, tostring 들고 있음
    public static class joinDTO {
        // static 이니까 new 하기전에 이 클래스는 static 에 뜬다.
        @NotEmpty
        private String username;
        @NotEmpty
        private String password;
        @Pattern(regexp = "^[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,6}$", message = "이메일 형식으로 작성해주세요")
        @NotEmpty
        private String email;

        // 매서드 만들기
        // 이 매서드는 DTO -> UserObject (유저 엔티티) 로 바꾸는 역할을 함!!
        public User toEntity() { // insert 하는건 toEntity로 만들어서 넣으면 완전 편리하고 코드가 심플해짐!!
            // 아래에서 유저객체 만들어서 return 함!
            return User.builder().username(username).password(password).email(email).build();
        }
    }
// 요청 바디 데이터 받기 위해 dto 생성함!!! (dto 만드는 목적)
    // 이렇게 만들어두면 관리하기 편하다.
    // 나중에 사용하기도 편함

    @Data // getter, setter, tostring 들고 있음
    public static class loginDTO {
        // static 이니까 new 하기전에 이 클래스는 static 에 뜬다.
        @Size(min = 2, max = 4) // 최소 2자, 최대 4자
        @NotEmpty
        private String username;
        @NotEmpty
        private String password;
    }
}