boram.log

[Cs Project] 동기 vs 비동기

Sun, 11 Jun 2023 18:55:30 GMT

동기 vs 비동기

동기 비동식 방식을 알아야 하는 이유

자바스크립트는 기본적으로 동기처리를 하기 때문에 결과가 오래 걸리는 코드를 작성시 결과가 나오기 전까지 아무것도 출력하지 않음
결과를 출력하기 전까지 "출력 중"이라는 문구정도는 나올 수 있게 하기 위해서 비동기 처리
이 외에도 동기 비동기 방식은 여러가지 알아두면 최적화에 도움이 많이 되기 때문에 꼭 알아야 함
동기식
동기식 : 클라이언트가 서버에게 요청을 보내면 다른 작업을 처리하지 않고 요청을 우선적으로 수행하는것을 의미
사진처럼 두 줄에 요청과 응답 존재,
- 말 그대로 클라이언트가 서버에게 요청을 보내면 응답을 받기 전까진 아무런 처리 x
- 클라이언트가 응답을 받게 되면 그때가 되서야 다른 요청을 처리하는 것을 동기식 즉 동기라고 함
이처럼 동기는 요청을 보내고 응답을 받는다 라는 전제
장단점
- 장점 : 응답의 순서를 보장
- 단점
  - 응답이 지연된다면 무작정 기다리게 됨
  - 응답이 지연되면 뒤에 들어오는 요청들은 연결가능한 쓰레드가 없어서 연결을 하지 못해 발생하는 여러 이슈가 생김
사용 예
- 채팅 프로그램
  - 사용자가 입력한 메시지를 서버로 전송하고, 서버는 메시지를 다른 사용자에게 전달
  - 메시지를 서버에 전송하고 서버는 다른 사용자에게 전송 이라는 방식 사용하므로 동기
- 웹 서버
  - 클라이언트로부터 요청을 받아 처리하는데 각각의 요청은 순차적으로 처리
- 계산기 프로그램
  - 입력값을 받고 연산하고 결과를 반환하는 구조

비동기식

동기식은 응답이 지연되도 계속 기다린다는 단점 존재 -> 이 부분을 보완한 방식이 비동기식

비동기식
- 클라이언트가 요청을 보내고나서 서버의 응답을 언제 받아도 상관 없다는 뜻으로 응답을 기다리지 않는 상태
- 응답을 기다리지 않으니 순서도 보장하지 않습니다.
사진처럼 두 줄에 요청과 응답 존재,
- 클라이언트가 요청을 보내고 나서 응답을 기다리지 않고 다음 요청을 보내거나 작업 진행
장단점
- 장점 : 클라이언트가 요청을 보내고 나서 응답을 기다리지 않으니 다른 일을 할 수가 있어 효율이 좋음
- 단점
  - 처리 결과를 보장받아야 하는 서비스에는 적합하지 않음
  - 결과를 확인하기 위해서는 콜백함수가 필요하니 복잡
사용 예
- 웹 애플리케이션, 네트워크 애플리케이션, 게임서버
  - 많은 사용자들이 동시에 접속해 요청
  - 이 요청의 처리 속도를 높이기 위해 비동기식 방식을 이용

블로킹 vs 논블로킹

동기/비동기를 잘 이해하기 위해서는 블로킹/논블로킹의 개념도 알아야 함
블로킹, 논블로킹은 제어권을 건내주느냐 안주느냐로 구분

제어권 : 행동할 수 있는 권리

블로킹

블로킹 : 사진 속 두 개의 함수 참고
- A 함수가 B 함수를 호출하면서 제어권도 B 함수에 넘겨줌
- 제어권을 넘겨받은 B는 함수를 실행하고 A는 B에게 제어권을 넘겨주었기 때문에 함수 실행을 잠시 멈춤
- B함수는 실행이 끝나면 자신을 호출한 A에게 제어권과 B함수 결과를 돌려주고 있음

논블로킹

논블로킹 : 사진 속 두 개의 함수 참고
- A함수가 B함수를 호출해도 제어권은 그대로 자신이 갖고 있음
- A함수가 B함수를 호출하면, B 함수는 실행되지만, 제어권은 A 함수가 그대로
- A함수는 계속 제어권을 가지고 있기 때문에 B함수를 호출한 이후에도 자신의 코드를 계속 실행

B 함수의 결과값은 어디로 갈까요? -> 조합에서 확인 가능

조합

논블로킹
- 동기
  - 완료될 때 까지 진행상황을 확인하기 위해 호출
  - 완료값을 확인 후 완료값 사용
- 비동기
  - 완료되는 시점이 중요 x
  - 하라고 냅두고 콜백으로 필요할 때 사용할 뿐
블로킹 : 두 개 다 파란함수는 결과가 반환될 때까지 대기
- 동기
  - 반환값을 기반으로 다음 함수를 진행
- 비동기
  - 호출 함수로 반환값을 받지만 그 값을 바로 이용할 지 안할지는 알 수 없음

즉,

블로킹 / 논블로킹: 한 작업이 처리되는 동안 다른 작업도 처리될 수 있는지
동기 / 비동기 : 작업들이 결과값을 순서대로 실행하는지 아닌지에 대해 나타냄

조합 예시

동기-블로킹

파란 박스
- 파란함수는 초록함수의 리턴값을 필요로 하는 동기식이고 그에 따라 파란함수에서 초록함수를 호출하고 제어권을 넘겨줌
- 그렇게 제어권을 초록함수에 넘겨주고 초록함수가 실행을 완료해서 리턴값과 제어권을 돌려줄때까지 파란함수는 기다리게 되는 동기 블로킹 방식
예시
- 코드를 보면 teacher함수를 실행하게 되면 선생님이 입실하는 메시지가 뜨고 student함수가 실행
- 이때 teacher함수는 student함수가 리턴값과 제어권을 돌려줄때까지 대기
- 그리고 student에 for문으로 문제푸는 메시지를 반복해서 출력합니다.
- student함수가 종료되서야 다시 teacher함수가 실행되고 선생님이 퇴실하는 메시지가 뜸

teacher는 student함수가 리턴할때까지 기다리는 동기구조 및 블로킹 방식이 되기 때문에 동기 블로킹 방식 성립

동기-논블로킹

노란박스
- 파란함수는 초록함수를 호출
- 이 때 파란함수는 초록함수에게 제어권을 주지 않고, 자신의 코드를 계속 실행함으로서 논블로킹 방식
- 그런데 파란함수는 초록함수의 리턴값이 필요하기 때문에, 중간중간 초록함수에게 함수 실행을 완료했는지 물어봄으로써 동기식 구조
영상 참고 : 퇴근시간 조회 버튼을 누르게 되면 남은 퇴근시간을 초 단위로 보여줌
- 버튼을 누르면 체크타임 함수를 불러오고
- 이 체크타임 함수는 셋팅된 퇴근시간과 현재시간을 빼 남은시간을 초단위로 불러옴

파란함수를 가상의 A 직원이 하는 업무, 그리고 퇴근시간을 조회하는 이 코드를 초록함수로 가정

A 직원은 자신의 업무 하면서 퇴근시간이 얼마나 남았는지 계속 알고 싶으니 초록함수를 수시로 확인
초록함수가 완료가 되면 퇴근시간이므로 A직원의 업무도 끝

즉,

직원은 완료 전에 업무를 계속하고 있으니 퇴근 시간을 조회하는 초록함수에게 제어권을 주지 않기에 논블로킹 방식
중간중간 수시로 퇴근시간이 얼마나 남았는지 확인함으로서 동기식 구조를 완성

비동기-블로킹

빨간박스
- 파란함수는 초록함수의 리턴값에 신경쓰지 않고, 콜백함수를 보내서 비동기 방식
- 그런데, 초록함수의 작업에 관심없음에도 불구하고, 파란함수는 초록함수에게 제어권을 넘겨서 블로킹 방식
- 그래서 파란함수는 자신과 관련 없는 초록함수의 작업이 끝날 때까지 기다려야 함
예시
- 직원이 출근 후 본인 일을 시작하고 작업진행 중 상사에게 서류를 제출
- 직원은 서류를 제출하고 그 서류가 상사에 의해 검토 완료 될 때까지 직원은 본인 일을 할 수 없음
- 제출한 서류의 검토가 끝나고 메일로 결과를 통보 받은 뒤에야 직원은 본인일을 마저 마칠 수 있음
예시 코드
- employee함수로 진행중에 manager라는 함수를 불러옴
- employee함수는 대기, manager함수가 진행
- manager함수는 i값이 100이 될때까지 계속해서 진행하고 i값이 100보다 커지면 검토 완료라는 메시지와 함께 manager함수는 종료
- manager함수가 종료되고 나서야 employee함수가 나머지 작업을 끝내고 서류검토를 완료했다는 코드

비동기 블로킹의 방식의 경우 동기식 블로킹과 차이가 거의 없어 사용 x

비동기 - 논블로킹

초록박스
- 파란함수가 초록함수를 호출할 때 제어권을 초록함수에 주지 않음으로서 논블로킹 방식
- 따라서 초록함수를 호출한 이후에도 멈추지 않고 자신의 코드를 계속 실행
- 초록함수를 호출할 때 콜백 함수를 함께 줌
- 초록함수는 자신의 작업이 끝나면 파란함수가 준 콜백함수를 실행
예시
- 사원은 본인 작업을 하다가 상사에게 서류를 제출하고 다시 본인 일을 하러 감
- 상사는 작업을 검토하고 그동안 사원은 계속 자기 할 일
- 상사는 검토가 끝나면 직원에게 이메일을 보내기만 하면 됨
예시 코드
- employee함수 실행
- 서류를 제출하면서 manager함수를 호출하지만 employee함수는 제어권을 넘기지 않기 때문에 바로 본인 일을 하러 감
- 실행된 manager함수를 보면 10마다 진행률을 보여줌
- 100이 되면 콜백함수를 호출하여 이메일 확인하라는 메세지를 출력하고 클리어인터벌함수로 갱신을 중단

마지막 정리

동기식과 비동기 블로킹과 논블로킹은 비슷하지만 바라보는 관점에서 차이
- 동기식과 비동기식은 순서와 결과값의 영향 여부
- 블로킹과 논블로킹은 제어권의 위치가 이동하는 지 여부

모두 추상적인 개념이라 어떤 메서드를 가지고 이렇다 저렇다 확실하게 나누기는 어렵다!!

출처

https://gyoogle.dev/ https://homoefficio.github.io/ https://velog.io/@nittre/

[Spring] 프로젝트 실전 ② - validation check

Mon, 08 May 2023 17:10:16 GMT

1. Name 입력 여부

(1) 라이브러리 추가

build.gradle에 다음 코드 추가 후 refresh gradle project
```
  implementation 'org.springframework.boot:spring-boot-starter-validation'
```
(2) @NotEmpty 추가
객체로 사용할 DTO에 메시지 추가

Name입력 필수

    @Getter @Setter
    public class MemberForm {

        @NotEmpty(message = "회원 이름은 필수입니다.")
        private String name;

        private String city;
        private String street;
        private String zipcode;

    }

(3) @Valid 추가

validation 다음에 binding 있으면 error를 Binding에 담아준다.

  @PostMapping("/members/new")
  public String create(@Valid MemberForm form, BindingResult result) {
      // result에 에러값 여부
      if( result.hasErrors() ) {
          return "members/createMemberForm";
      }

      Address address = new Address(form.getCity(), form.getStreet(), form.getZipcode());
      Member member = new Member();
      member.setName(form.getName());
      member.setAddress(address);

      memberService.join(member);

      return "redirect:/";
  }

name 입력 ❌
- result 객체에 message = "회원 이름은 필수입니다." 받아서 처리 -> 에러를 담아서 다시 회원가입 페이지 -> input 박스에 에러메세지 담기
name 입력 ⭕
- 내용 저장
  (4) input box에 에러 메세지 담기
  
  ① 에러여부에 따라 class명 바꾸기
```
 - 에러 x : 'form-control' 
- 에러 o : 'form-control fieldError'
```
  ② @NotEmpty(message = "회원 이름은 필수입니다.")불러오기
👍 결과*

2. Name 중복 여부

(1) @service에서 repository.save가 실행되기전에 메서드 추가

    @Transactional
    public Long join(Member member){
        // name 중복 체크 메소드 호출
        validationMemberCheck(member);
        memberRepository.save(member);
        return member.getId();
    }

(2) 메서드 만들기

@Service

    // 호출시켜주는 곳에 예외라고 던져주는 것
    private void validationMemberCheck(Member member) throws IllegalAccessException {
        List findMembers = memberRepository.findByName(member.getName());

        // findMembers가 비어있어야 정상, 비지 않았으면 exception
        if( !findMembers.isEmpty() ) {
            //exception 객체 생성 후 던지기
            throw new IllegalAccessException("이미 존재하는 회원입니다.");
        }
    }

@Repository

    // service단에 만들었던 예외 처리
    public List findByName(String name) throws IllegalAccessException {
        return em.createQuery("select m from Member where m.name = :name", Member.class)
                 .setParameter("name", name)
                 .getResultList();
    }

(3) 예외 처리 : 메서드, 메서드 호출하는 곳, 서비스랑 연결된 곳

@Controller

    @PostMapping("/members/new")
    public String create(@Valid MemberForm form, BindingResult result) throws IllegalAccessException {
                        ....메소드....
    }

@Service

    @Transactional
    public Long join(Member member) throws IllegalAccessException {
                        .... 메소드 ....
    }

👍 결과

같은 이름 입력하면 was단 -> 500 error 발생
콘솔창 출력

[Spring] 프로젝트 실전 ①

Mon, 08 May 2023 16:30:52 GMT

1. 오류 확인하기 - Logger

Logger log = LoggerFactory.getLogger(getClass());을 불러오거나

lombok쓰고 있으면 @Slf4j로 대체

@Controller
@Slf4j
public class HomeController {

// Logger log = LoggerFactory.getLogger(getClass());

@RequestMapping("/")
public String home() {
    log.info("home controller"); 
    return "home";    //home.html로 찾아간다.
}

}

- **콘솔창 출력**
![](https://velog.velcdn.com/images/boram_han/post/150165dc-a524-490b-856f-634fe3f97921/image.png)
> 쉽게 현재 위치 파악 가능

# 2. DTO 객체 사용
- 엔티티로 사용할 DTO 따로 객체로 사용할 DTO 따로 사용

**MemberForm.java**
```java
    @Getter @Setter
    public class MemberForm {

        private String name;
        private String city;
        private String street;
        private String zipcode;

    }

controller에 객체 그대로 넘길 수 있음

    @GetMapping("/members/new")
    public String createForm(Model model) {
        model.addAttribute("memberForm", new MemberForm());
        return "members/createMemberForm";
    }

타임리프에서 th:object, th:field 사용

        
            
                이름

3. 프로젝트에서 JPA 사용

EntityManagerFactory 주입
- @PersistenceUnit를 사용하면 되긴하나 굳이 사용 ❌
EntityManager 불러오기
- @PersistenceContext도 굳이 사용 ❌
- @Autowired가 대신 처리
  - 대신, private final EntityManager em;
  - final키워드 필요
- final 키워드가 있는 생성자 : @RequiredArgsConstructor가 생성자 처리 가능

👍 결론

    @Repository
    @RequiredArgsConstructor
    public class MemberRepository {
        private final EntityManager em;
    }

4. Service 클래스 - @transactional

(1) @transactional

DB와 관련된, 트랜잭션이 필요한 서비스 클래스 혹은 메서드에 @Transactional 추가
- repository가 잘 안되면 service영역까지 rollback
- 즉, 일련의 작업들을 묶어서 하나의 단위로 처리할 때

import 시 스프링에서 제공하는 것으로 사용

    org.springframework.transaction.annotation.Transactional

(2) @transactional 옵션

readOnly = true or false
- 사용 하는 이유
  - 읽기전용일 때 사용
  - 비용을 아끼게 되므로 많이사용
class차원에 어노테이션 처리
- @Transactional(readOnly=true)
- 전체 메서드에 적용
class의 메서드 중 join메서드
- insert이므로 읽기 전용이면 안됨
- 그러면 따로 @Transactional을 써두면 됨
  클래스 레벨에서 transactional주는 것과 메서드에서 transaction 하는 것의 차이?
  - 그냥 select에 걸어주는 습관 같은 것, insert에만 transactioanl 따로 해주는 것이 관례

5. embedded 객체 타임리프로 받아오기

addresss 객체 통째로 members에 담겨있을 때

[Spring] ENUM

Mon, 08 May 2023 15:34:01 GMT

📋 ENUM

(1) ENUM이란

Enumeration Type(열거타입)
- 데이터 중에서 요일(월,화,수,목,금,토,일), 계절(봄,여름,가을,겨울) 등과 같이 몇 가지 한정된 값을 갖는 경우
- 요일, 계절등과 같이 한정된 데이터만을 가지는 타입
Enumeration constant(열거 상수)
- 월, 화, 수, 등 열거되는 값
네이밍 방법
- 타입 이름
  - 첫 글자를 대문자로 하여 생성
- 열거상수
  - 대문자로 작성
  - 2개의 단어로 연결 되어 있을 때는 _로 연결

(2) ENUM의 장점

코드가 단순해지며 가독성이 좋아짐
인스턴스 생성과 상속을 방지하여 상수값의 안정성이 보장됨
enum 예약어를 사용하므로 열거 의도를 분명히 함

(3) ENUM과 메모리 구조

열거 상수는 상수 각각을 내부적으로 public static final 필드이면서 객체로 제공되도록 함
static이 붙어있음
- 각각의 상수는 클래식 변수
- 클래스로더가 로드 시점에 JVM 메소드 영역에 해당 클래스 변수들을 항상 상주시킴
- 프로그램이 종료되기 전에는 언제든지 가져다 쓸 수 있는 주소공간을 확보

(4) ENUM 사용

1) 단순 열거

◾ ENUM

    public enum Week {

        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

        public void dayInfo() {
            System.out.println("dayInfo enum");
        }
    }

◾ 구현

    public static void main(String[] args) {
        Week today = Week.FRIDAY;
        System.out.println(today);

        // enum에서 지정한 메서드 불러오려면 열거상수 먼저 불러와야 함
        Week.MONDAY.dayInfo();
    }

◾ 결과

2) 이름과 값 부여

◾ ENUM

    public enum Type {

        // static final String WALKING = "워킹화";
        // -> 보기 편하게 만든 클래스가 ENUM 
        // -> 1.5버전부터 쓰기 시작한 것
        WALKING("워킹화"),
        RUNNING("등산화"),
        TRACKING("트래킹화"),
        HIKING("등산화");

        final private String name;

        private Type(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

◾ 구현

    public static void main(String[] args) {
        for( Type type : Type.values()) {
            System.out.println(type.getName());
        }
    }

◾ 결과

3) JPA에서 사용

@Enumerated(EnumType.데이터 타입) 사용

◾ ENUM

    public enum OrderStatus {
        ORDER, CANCEL;
    }

◾ Order.java

    // 주문상태 (Order, Cancel)
    @Enumerated(EnumType.STRING)
    private OrderStatus status;

[JPA] JPQL

Mon, 08 May 2023 15:11:29 GMT

💻 JPQL

1. JPQL

Java Persistence Query Language
JPA가 제공하는 객체 지향 쿼리 언어
- JPA를 사용하면 엔티티 객체를 중심으로 개발
- JPA는 SQL을 추상화환 JPQL이라는 객체 지향 쿼리 언어 제공
- JPA는 JPQL을 분석한 후 적절한 SQL을 만들어서 데이터베이스를 조회
SQL vs JQPL
- SQL : 데이터베이스 테이블을 대상으로 쿼리
- JQPL : 엔티티 객체를 대상으로 쿼리
  - SQL과 문법 유사 -> select, from, where, group by, having, join 지원
  - SQL을 추상화해서 특정 데이터베이스 SQL에 의존하지 않음

💡 SQL

    select * from Member m where m.age>18

💡 JPQL

    String jpql = "select m from Member m where m.age > 18"; 
    List result = em.createQuery(jpql, Member.class)
                            .getResultList();

2. JPQL 사용하기

(1) 사용 기본

① 대소문자 구분

엔티티와 속성은 대소문자를 구분
- Member -> member ❌, age-> Age ❌
JPQL 키워드는 대소문자 구분 ❌
- SELECT -> select ⭕, WHERE -> where ⭕

② 엔티티 이름

테이블명 대신 엔티티명을 사용
- @Entity(name="")으로 설정 가능
지정하지 않을 시 클래스 명을 기본값으로 사용(추천)
③ 별칭은 필수(알리야스)
JPQL은 별칭은 필수

as는 생략 가능

  em.createQuery( "select m from Member as m" );
                          ↓
  em.createQuery( "select m from Member m" );

(2) JPQL 문법

select 문

  select 절
  from 절
  where 절
  group by 절
  having 절
  orderby 절

update 문
```
  update 절 where 절
```
delete문
```
delete 절 where 절
```

집합과 정렬

  select count(m),        // 회원수
          sum(m.age),     // 나이 합
          avg(m.age),        // 평균 나이
          max(m.age),        // 최대 나이
          min(m.age)        // 최소 나이
  from Member m

(3) 반환 타입 지정

TypeQuery : 반환 타입이 명확할 때 사용

💡 반환타입 정확히 MEMBER*

   TypeQuery query = 
       em.createQuery("select m from Member m", Member.class);

Query : 반환 타입이 명확하지 않을 때 사용

💡 여러개 SELECT -> 타입 불명확*

   Query Query = 
       em.createQuery("select m.username, m.age from Member m");

(4) 결과 조회

반환된 객체 출력하기 위해 사용
query.getResultList()
- 결과가 하나 이상일 때, 리스트 반환
  - 결과가 없으면 빈 리스트 반환
  - 빈 collection이 반환되기 때문에 NullPointerException에 대한 걱정은 하지 않아도 됨
query.getSingleResult()
- 결과가 정확히 하나(조심)
- 단일 객체 반환
  - 결과가 없으면 : javax.persistence.NoResultException
  - 결과가 둘 이상이면 : javax.persistence.NonUniqueResultException

(5) 파라미터 바인딩

이름 기준 : 변수앞에 :

Member singleResult1 = em.createQuery("select m from Member as m where m.username = :username", Member.class)
                        .setParameter("username", "member1")
                         .getSingleResult();

위치 기준 : 실질 사용 ❌

em.createQuery("select m from Member as m where m.username = ?1", Member.class)
.setParameter(1, "member1");

(6) 프로젝션

select 절에 조회할 대상을 지정하는 것
프로젝션 대상 : 엔티티, 임베디드 타입, 스칼라 타입(숫자, 문자등 기본 타입)

💡 엔티티 프로젝션

Member 엔티티 조회

  List result = em.createQuery("select m from Member m", Member.class)
                          .getResultList();

Member와 관련된 team 조회

  List result2 = em.createQuery("select m.team from Member m", Team.class)
                         .getResultList();

join문으로 Team 조회

  List result2 = em.createQuery("select t from Member m join m.team t", Team.class)
                         .getResultList();

💡 임베디드 타입 프로젝션*

   // 직접 가져올 수 없고 o.address가 소속되어 있는 엔티티에서 가지고 와야 함
   List findAddress = em.createQuery("select o.address from Order o", Address.class)
                                   .getResultList();

💡 스칼라 타입 프로젝션*

object 받아오기

  // 여러 값 조회
  List resultList = em.createQuery("select m.username, m.age from Member m")
                      .getResultList();

  // 타입을 지정하지 못하니까 object 받아오기
  Object o = resultList.get(0);

  // 배열로 담겨 있어야 꺼내쓰기가 쉬움
  Object[] result3 = (Object[])o;
  System.out.println("username = " + result3[0]);
  System.out.println("age = " + result3[1]);

Object배열의 리스트

  List resultList2 = em.createQuery("select m.username, m.age from Member m")
                                 .getResultList();

  Object[] result4 = resultList2.get(0);
  System.out.println("username = " + result4[0]);
  System.out.println("age = " + result4[1]);

DTO

  List result5 
      = em.createQuery("select new com.codingbox.jpql.MemberDTO(m.username, m.age) from Member m")
          .getResultList();

  MemberDTO memberDTO = result5.get(0);

  System.out.println("memberDTO = " + memberDTO.getUsername());
  System.out.println("memberDTO = " + memberDTO.getAge());

MemberDTO

@Getter @Setter
public class MemberDTO {

  private String username;
  private int age;

  public MemberDTO(String username, int age) {
      super();
      this.username = username;
      this.age = age;
  }
}

(7) 페이징 API

페이징 처리를 위해서는 order by 사용
JPA는 페이징을 다음 두 API로 추상화
- setFirstResult(int startPosition) : 조회 시작 위치(0부터 시작)
- setMaxResults(int maxResult) : 조회할 데이터 수

몇 번째 부터 몇 개 가지고 올 것인가

   // 나이 순으로 멤버 조회
   String jpql = "select m from Member m order by m.age desc";
   // 10번째 부터 20개 데이터 조회
   List resultList = em.createQuery(jpql, Member.class)
                               .setFirstResult(10)
                               .setMaxResults(20)
                               .getResultList();

   // 멤버 리스트 조회
   System.out.println("result.size : " + resultList.size());

   for(Member member1 : resultList) {
       System.out.println("member 1 = " + member1);
   }

(8) 조인

문법이 객체 스타일

내부 조인 : inner 생략 가능

  String jpql = "select m from Member m inner join m.team t";
  List resultList = em.createQuery(jpql, Member.class)
                              .getResultList();

외부 조인 : outer 생략 가능

  String jpql2 = "select m from Member m left outer join m.team t";
  List resultList2 = em.createQuery(jpql2, Member.class)
                               .getResultList();

세타 조인 (연관관계가 없는 조인)

  String jpql3 = "select m from Member m, Team t where m.username = t.name";
  List resultList3 = em.createQuery(jpql3, Member.class)
                               .getResultList();

(9) 서브 쿼리

SQL과 마찬가지로 서브쿼리도 JPQL에서 지원
하지만 FROM문에 대한 서브쿼리는 지원 ❌

조인으로 풀 것

  String jpql = "select m from Member m where m.age > (select avg(m2.age) from Member m2)";
  List resultList = em.createQuery(jpql, Member.class)
                              .getResultList();

[JPA] 값 타입

Thu, 04 May 2023 09:15:45 GMT

💱 값 타입

(1) 엔티티 타입 vs 값 타입

◾ 엔티티 타입

@Entity를 붙여서 관리하던 클래스들
PK값으로 관리가 되기때문에 데이터가 변해도 쉽게 추적이 가능하고 관리도 편리

👀 PK값

"Primary Key(기본 키)"

각 레코드를 고유하게 식별하는 데 사용되는 필드(열) ex. 사용자 고유의 ID

◾ 값 타입

int, String과 같은 단순히 값으로 사용하는 자바 기본타입이나 객체
추적하기가 어려움

(2) 값 타입

1) 기본값 타입

자바 기본타입(int, double..), 래퍼클래스(Integer, Long..), String
생명주기를 엔티티한테 의존
예를 들어, Order 엔티티를 생성할 때 함께 OrderDate 객체도 생성되며, Order 엔티티가 삭제될 때 OrderDate 객체도 함께 삭제
2) 임베디드 타입
복합 값타입으로 새로운 값 타입을 직접 정의할 수 있다.
예를 들어 회원 정보에서 비슷한 정보끼리 묶어 관리하고 싶다면 그런 묶음을 임베디드 타입으로 만들어 주고 사용

(3) 임베디드 타입(EMBEDDED TYPE)

Period : 회원 정보 중 startDate, endDate를 묶은 것
Address : 회원 정보 중 city, street, zipcode를 묶은 것
이런 묶음을 임베디드 타입이라고 함

1) JPA에서 임베디드 타입 사용법

@Embeddable
- 값 타입을 정의하는 곳에 표시
@Embedded
- 값 타입을 사용하는 곳에 표시
기본 생성자 필수
@Embeddable과 @Embedded 둘 중에 하나만 넣어도 되지만 둘 다 넣는 것을 권장

💡 예시

@Embeddable

@Embeddable
@Getter @Setter
public class Address {

  private String city;
  private String street;
  private String zipcode;

  public Address(String city, String street, String zipcode) {
      super();
      this.city = city;
      this.street = street;
      this.zipcode = zipcode;
  }    
  // 기본생성자는 반드시 있어야 한다.
  public Address() { }
}

@Embedded

@Entity
@Getter @Setter
public class Member {

  @Id @GeneratedValue
  private Long id;

  @Column(name = "name", nullable = false)
  private String username;

  @Embedded
  private Address address;

}

- 실행파일에서 사용하기
```java
try {
     Member member = new Member();
     member.setUsername("user");
     member.setAddress(new Address("서울", "역삼", "123"));
 }

2) 임베디드 타입의 장점

재사용성
높은 응집도
임베디드 타입에 사용할 특정 메서드를 따로 관리가능
임베디드 타입을 포함한 모든 값 타입은 값 타입을 소유한 엔티티 생명주기를 의존

3) 임베디드 타입과 테이블 매핑

임베디드 타입은 엔티티의 값
임베디드 타입을 사용하기 전과 후에 매핑하는 테이블은 같음
객체와 테이블은 아주 세밀하게 매핑하는 것이 가능
잘 설계한 ORM 애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많음

4) @AttributeOverride : 속성 재정의

같은 임베디드 타입을 여러 개 쓰고 싶은 경우 @AttributeOverrides, @AttributeOverride어노테이션 사용

💡 예시

    // 집주소
    @Embedded
    private Address address;

    // 회사 주소
    @Embedded
    @AttributeOverrides({
        @AttributeOverride(name = "city", column = @Column(name = "WORK_CITY")),
        @AttributeOverride(name = "street", column = @Column(name = "WORK_STREET")),
        @AttributeOverride(name = "zipcode", column = @Column(name = "WORK_ZIPCODE"))
    })
    private Address workAddress;

5) 객체 타입의 한계

💡 하나의 객체 타입 값을 2객체에 할당

    Address addr = new Address("서울", "역삼", "123");

    Member member = new Member();
    member.setUsername("user1");
    member.setAddress(addr);
    em.persist(member);

    Member member2 = new Member();
    member2.setUsername("user2");
    member2.setAddress(addr);
    em.persist(member2);

    tx.commit();

💡 그 중 한 객체의 값 변경

    member.getAddress().setCity("newCity");

👍 결과 🚫 오류 user1, user2의 city값이 다 바뀜 🚫

이유
- 기본데이터 타입 변수일 때 -> 재할당 가능
  - a라는 공간에 10 대입
  - b라는 공간에 a값 복붙
```
int a = 10; 
int b = a
```
- 객체 공유 : 클래스 공유
  - 공간 없음
  - 각각의 클래는 주소값을 가지고 있는 new Member() 객체를 가리키기만 하고 있음
  - 그러므로 member1 클래스에서 city값을 바꾸면** new Member() 객체 주소의 city** 변경
  - member2 클래스는 바뀐 new Member()객체를 그대로 가리키고 있음
  - 밖에서 볼 때는 a, b클래스 city값 전체 수정

임베디드 타입처럼 직접 정의한 값 타입은 자바의 기본타입이 아니라 객체 타입
- 자바 기본 타입에 값을 대입하면 값을 복사한다.
- 객체 타입은 참조 값을 직접 대입하는 것을 막을 방법이 없음
항상 값을 복사해서 사용하면 공유 참조로 인해 발생하는 부작용을 피할 수 있음
해결법
- 새로운 객체를 무조건 만들어서 할당
- setter를 없앤다

💡 기본값타입들을 복사해서 넘겨주는 방식

    Address addr = new Address("서울", "역삼", "123");
    // 새로운 객체 생성
    Address copyAddr = new Address(addr.getCity(), addr.getStreet(), addr.getZipcode());

    Member member = new Member();
    member.setUsername("user1");
    member.setAddress(addr);
    em.persist(member);

    Member member2 = new Member();
    member2.setUsername("user2");
    // 새로운 객체 할당
    member2.setAddress(copyAddr);
    em.persist(member2);

    // 1번째 member 주소만 바꾸고 싶어
    member.getAddress().setCity("newCity");

    tx.commit();

[Spring] YamL

Thu, 04 May 2023 08:10:20 GMT

☘ Yaml (설정파일 *.yml)

yaml은 파일 작성에 자주 사용되는 데이터 직렬화 언어이자, 데이터 표현 양식의 한 종류
사용자가 보고 이해하기 쉬운 형태를 가지고 있기 때문에 최근들어 많이 활용되는 데이터 포멧

(1) properties vs yml

한 눈에 보기에 가독성이 좋다.
불필요한 코드의 반복을 피할 수 있다.
계층 구조로 이해하기 쉽고 쓰기 편하다.

(2) 주의사항

계층 간 : 띄어쓰기 2칸
값 : 띄어쓰기(스페이스) 1칸

💡 application.yml

#port 수정
server:
  port: 9092

#DB Connection
spring:
  datasource:
    url: jdbc:oracle:thin:@localhost:1521:xe
    driver-class-name: oracle.jdbc.OracleDriver
    username: spring
    password: spring

# JPA (spring 영역이므로 두칸 띄어쓰기)
  jpa:
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        format_sql: true
        show_sql: true

#thymeleaf 설정
  thymeleaf:
    cache: false

DB, JPA, THYMELEAF 모두 spring에 속하므로 2칸 띄어쓰기

[JPA] 연관관계 매핑

Mon, 01 May 2023 15:03:22 GMT

연관관계 매핑

객체 설계를 테이블 설계에 맞춘다면?

1) Member, Team 객체 생성

Member 객체생성

  @Entity
  public class Member {

      @Id @GeneratedValue
      private Long id;

      @Column(name = "USERNAME") 
      private String name;

      @Column(name = "TEAM_ID")
      private Long teamId; 
  }

Team 객체생성

  @Entity
  public class Team {

      @Id @GeneratedValue 
      private Long id;

      private String name; 
   }

2) 멤버의 team을 알고 싶을 때

Team, Member 영속상태

  //팀 저장
  Team team = new Team();
  team.setName("TeamA");
  em.persist(team);

  // 회원 저장
  Member member = new Member();
  member.setName("member1");
  member.setTeamId(team.getId());
  em.persist(member);

멤버의 team 찾기

  // 멤버 id로 멤버 정보 찾기
  Member findMember = em.find(Member.class, member.getId());
  // 그 결과로 teamId 찾기
  Long findTeamId = findMember.getTeamId();
  // 찾은 teamId로 team정보 가져오기
  Team findTeam = em.find(Team.class, findTeamId);
  // 가져온 team정보로 team 이름 알아내기
  System.out.println("findTeam : " + findTeam.getName());

결론

번거로움

저장된 teamId를 이용해서 팀 조회 -> 객체지향적인 방법이라고 보기 어려움

member와 team의 연관관계가 없음

(1) 연관관계 매핑 기초

객체지향적인 모델링을 위해 연관관계 매핑

객체와 테이블의 연관관계를 이해하고 객체의 참조와 테이블의 외래키를 매핑
용어
- 방향(Direction) : 단방향, 양방향
- 다중성(Multiplicity) : 다대일(N:1), 일대다(1:N), 일대일(1:1), 다대다(N:N)
- 연관관계 주인(Owner) : 객체 양방향 연관관계는 관리 주인이 필요

🙆‍♀️ 객체와 테이블 차이

테이블 : 외래 키로 조인을 사용해서 연관된 테이블을 찾음
객체 : 참조를 사용해서 연관된 객체를 찾음

(2) 단방향 연관관계

객체지향적으로 모델링하는 법

Member안에 team이라는 객체 넣기
- 객체가 참조를 바로할 수 있음

1) 연관관계 가진 Member, Team 객체 생성

① Member객체 생성

team객체를 통으로 가지고 옴
FK를 걸어줘야 하는 곳에 Join 걸어줌
@ManyToOne : 많은 것들 중 하나
- 많은 것 : 멤버 수, 하나 : 팀 이름
@JoinColumn
- 관계 컬럼을 적어줌

@Entity
@Getter @Setter
public class Member {

    @Id @GeneratedValue
    @Column(name="MEMBER_ID")
    private Long id;

    @Column(name="USERNAME")
    private String name;

    @ManyToOne
    @JoinColumn(name = "TEAM_ID")
    private Team team;
}

👀 외래키

외래키가 포함된 테이블이 자식 테이블
기준이 되는 테이블의 내용을 참조해서 레코드가 입력

② Team 객체 생성

@Column의 name 속성과 @JoinColumn의 name 속성은 반드시 같아야 함

@Entity
@Getter @Setter
public class Team {

  @Id @GeneratedValue
  @Column(name="TEAM_ID")
  private Long id;
  private String name;
}

2) 멤버의 team을 알고 싶을 때

① Team, Member 영속상태

//팀 저장
Team team = new Team();
team.setName("TeamA"); 
em.persist(team);

//회원 저장 Member member = new Member(); member.setName("member1"); // member.setTeamId(team.getId()); // 단방향 연관관계 설정, 참조 저장 member.setTeam(team);

em.persist(member);

#### ② 멤버의 team 찾기
```java
    // 멤버 id로 멤버 정보 찾기
    Member findMember = em.find(Member.class, member.getId());
    // 멤버 정보에서 객체 team 찾아냄
    Team findTeam = findMember.getTeam();
    // team의 이름 찾아냄
    System.out.println("findTeamName : " + findTeam.getName());

결론

team객체를 넘겨주면 알아서 teamId를 찾아 FK값으로 쓰고 연관관계를 설정

team을 getTeam을 이용해서 참조로 가져옴

(3) 양방향 연관관계

단방향 매핑 후, Team의 Member들을 역참조 : 양방향 객체 연관관계

1) Member, Team 객체 양방향 연관관계 맺기

① Member객체 생성

단방향과 똑같이

@Entity
@Getter @Setter
public class Member {

  @Id @GeneratedValue
  @Column(name="MEMBER_ID")
  private Long id;

  @Column(name="USERNAME")
  private String name;

  @ManyToOne
  @JoinColumn(name = "TEAM_ID")
  private Team team;
}

② Team 객체 생성

Team에 members 리스트를 추가

@OneToMany 어노테이션 붙이고 mappedBy로 연결할 객체 넣어줌

여기선 Member 클래스의 Team team 객체

@Entity
@Getter @Setter
public class Team {

@Id @GeneratedValue
@Column(name="TEAM_ID")
private Long id;

private String name;

@OneToMany(mappedBy = "team")
List members = new ArrayList();
}

③ 역참조 가능

team.getMembers();

2) 연관관계의 주인(Owner)

① 테이블, 객체에서의 연관관계

테이블(DB)에서의 연관관계
- FK값으로 JOIN을 통해서 양방향 접근 가능
객체에서의 연관관계
- 회원 -> 팀, 팀 -> 회원 연관관계
- 단방향 연관관계 2개
  ② 딜레마 : Member에서 Team값을 수정하고 싶을 때
DB 입장
- MEMBER에 있는 TEAM_ID만 UPDATE해도 수정 가능
객체 입장 :
- TEAM에서 MEMBER 수정? OR MEMBER에서 TEAM 수정?
  ③ 두 관계중 하나를 연관관계의 주인(Owner)으로 지정
주인이 아닌 쪽에 mappedBy
- mappedBy : 내가 누군가에 의해 MAPPING 되었다는 뜻
항상 외래키가 있는 곳을 주인 -> 비즈니스 로직을 기준 ❌
- @ManyToOne을 포함하는 클래스가 주인
- 여기서는 Member.team 이 연관관계의 주인
  ④ 연관관계의 주인(Owner)
주인만이 외래키를 관리
주인쪽만 연관관계를 등록하고 수정가능
주인이 아닌 쪽은 읽기만 가능
주인쪽에서 연관관계를 생성하는 코드 추가
```
  member.setTeam(team);   
```

3) Team에 담긴 member 리스트 보기

    try {
            Team team = new Team();
            team.setName("TeamA");
            em.persist(team); // 영속상태

            Member member = new Member();
            member.setName("member1");
            // 연관관계 생성하는 코드 추가
            member.setTeam(team);
            em.persist(member);

            // 양방향 매핑
            Member findSideMember = em.find(Member.class, member.getId());
            // 팀은 멤버를 가지고 있고 
            List members = findSideMember.getTeam().getMember();

            for(Member m : members) {
                System.out.println("result = " + m.getName());
            }

            tx.commit(); // db에 적용되는 자리 
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
            emf.close();
        }

4) 최적화

① 위의 코드 : 실행 ❌ (null)

why? 아직 관계 생성 ❌ = DB에 반영 ❌
- 영속성 컨텍스트에 들어가 있는 데 (1차 캐시) -> 영속성 컨텍스트는 변경된 것을 감지하지 못함

② flush 추가

em.persist 뒤에 flush로 DB에 쿼리를 날려주고 캐시를 참고하지 않도록 clear까지 해주면 DB에서 가져올 수 있음

출력 가능한 상태

try {
        Team team = new Team();
        team.setName("TeamA");
        em.persist(team); // 영속상태

        Member member = new Member();
        member.setName("member1");
        member.setTeam(team);
        em.persist(member);

        // 강제로 DB쿼리를 보고 싶을 때 사용
        em.flush();
        em.clear();

        Member findSideMember = em.find(Member.class, member.getId());
        List members = findSideMember.getTeam().getMember();

        for(Member m : members) {
            System.out.println("result = " + m.getName());
        }

        tx.commit(); // db에 적용되는 자리 
    } catch (Exception e) {
        tx.rollback();
    } finally {
        em.close();
        emf.close();
    }

③ 순수 객체로 사용하기

flush 호출을 매번하는 것은 번거롭고 실수할 가능성 높임
- flush 자리에 team.getMembers().add(member); 추가
- Team은 주인이 아니므로 읽기만 가능
- 양쪽 객체에 값을 모두 입력시키는 것
- DB에 다녀오지 않고 객체 상태로만 사용 가능

④ 주의사항

수동으로 값을 입력하는 것 : 실수 유발
무한루프 주의
- toString 실행 시, member객체는 team객체를 부르고 team객체는 member객체를 부름

⑤ 최종 해결

Member.java
- Member를 기준으로 team 넣을 경우
- 기존의 setter 변경한 다음 메서드 추가
```
      public void changeTeam(Team team) {
    this.team = team;
    // this : 나 자신의 인스턴스를 넣어준다.
    team.getMember().add(this);
}
```
  - 기존의 setter 변경 : 이름 바꾸기
  - @Setter(value = AccessLevel.NONE)
    - lombok에서 자동으로 setter생성을 막아줌
```
@Entity
@Getter @Setter
public class Member {
```
  @Id @GeneratedValue @Column(name = "MEMBER_ID") private Long id; @Column(name = "USERNAME") private String name;
  
  @ManyToOne @JoinColumn(name = "TEAM_ID") @Setter(value = AccessLevel.NONE) // setter생성을 막아줌 private Team team;
  
  /*
  - 일반적인 setter의 형태(자바에서의 관례 형태를 벗어났다)가 아니면 이름을 바꿔준다.
  - 그럼 추후 소스코드를 봤을때 단순 settet작업이 아닌 중요한 작업을 진행하는지를 파악 할 수 있다.
  - / public void changeTeam(Team team) { this.team = team; // this : 나 자신의 인스턴스를 넣어준다. team.getMember().add(this); }
  public void setTeam(Team team) {
```
this.team = team;
```
  } } ```

Team.java

Team을 기준으로 member를 넣을 경우

team에 멤버 입력 시 자동으로 member측에도 team값 설정

@Entity
@Getter @Setter
public class Team {
@Id @GeneratedValue
@Column(name = "TEAM_ID")
private Long id;
private String name;

@OneToMany(mappedBy = "team")
private List member = new ArrayList<>();

public void addMember(Member member) {
    member.setTeam(this);
    this.member.add(member);
}
}

최종 최적화 코드

  try{
      Team team = new Team();
      team.setName("TeamB");
      em.persist(team);

      Member member = new Member();
      member.setName("member2");

      //member.changeTeam(team);    // 1안 : member를 기준으로 team을 넣는다.
      em.persist(member);

      team.addMember(member);        // 2안 : team을 기준으로 member를 넣는다.

      Team findTeam = em.find(Team.class, team.getId());
      List members = findTeam.getMember();

      System.out.println("members = " + findTeam);

      for( Member m : members ) {
              System.out.println("result = " + m.getName());
      }

      tx.commit();

  }catch (Exception e) {
          tx.rollback();
  } finally {
      em.close();
      emf.close();
  }

5) 양방향 매핑 정리

단방향 매핑만으로도 이미 연관관계 매핑은 완료
양방향 매핑은 반대 방향으로 조회 기능이 추가
- 양방향 사용 이유 : JPQL에서 양방향으로 탐색할 일이 많음
단방향 매핑을 메인으로 사용하고 양방향 매핑은 필요할 때 추가하기
- 양방향 : select를 좀 더 직관적으로 하고 싶을 때 사용, 테이블에 영향을 주지 않음

결론

객체입장에서 양방향 매핑은 이득이 별로 안되므로 필수가 아님.
필요시에 생성하기 (옵션)

[JPA] Entity mapping

Sun, 30 Apr 2023 16:00:42 GMT

🌍 Entity mapping

JPA를 이용해 데이터베이스의 테이블과 상호 작용(데이터 저장, 수정, 조회, 삭제 등) 하기 위해 먼저 해야 하는 작업은 데이터베이스 테이블과 엔티티 클래스 간의 매핑 작업

사용 어노테이션

객체와 테이블 매핑 : @Entity, @Table
필드와 컬럼 매핑 : @Column
기본 키 매핑 : @Id
연관관계 매핑 : @ManyTOne, @JoinColumn

1. 객체와 테이블 매핑 : @Entity, @Table

(1) @Entity

@Entity가 붙은 클래스는 JPA 관리 엔티티

JPA를 사용해서 테이블과 매핑할 클래스는 @Entity 필수

주의사항
- 기본 생성자 필수 (파라미터가 없는 public 또는 protected 생성자)
- 저장 필드에 final 사용 ❌
- final 클래스, enum, interface 사용 ❌
- 즉, 일반 클래스로 만들면 됨
속성
- name 속성
```
  @Entity(name = "Member2")
```
- JPA에서 사용할 엔티티 이름을 지정가능
- 기본값 : 클래스 이름을 그대로
- 같은 클래스 이름이 없으면 가급적 기본값을 사용할 것

(2) @Table

@Table 엔티티와 매핑할 테이블

속성
- name : 매핑할 테이블 이름 , 엔티티 이름을 사용
- catalog : 데이터베이스 catalog 매핑
- schema : 데이터베이스 schema 매핑
- uniqueConstraints(DDL) : DDL 생성 시에 유니크 제약 조건 생성
- ```
@Entity
@Table(name = "MBR")
public class Member {
    @Id
    private Long memberId;
}
```

🙆‍♀️ DDL 명령어

DDL 명령어에 대한 자동 생성 여부
- persistence.xml에서 조정 가능
- 속성 : value="속성"
- CREATE은 실무단계에서 절대 사용하지 않음

DDL 생성기능

DDL을 자동 생성할 때(value="create")만 사용. JPA의 실행 로직에는 영향 ❌

제약조건 추가

// 회원 이름을 필수, 10자 초과X
   @Column(nullable = false, length = 10)
   private String name;

유니크 제약조건 추가

 @Entity
  @Table(name = "MBR",
           uniqueContraints={
               @UniqueConstraint(name="NAME_AGE_UNIQUE",
               columnNames={"NAME","AGE"})})
  public class Member {
      @Id
      private Long memberId;
}

2. 필드와 컬럼 매핑

필드 차원에서의 매핑 어노테이션

필드 매핑 어노테이션 종류

@Entity
@Getter @Setter
@Table(name = "MBR")
public class Member {

    @Id
    private Long id;

    @Column(unique = true, length = 10)
    private String name;

    @Column(name = "myage")
    private int age;

    // DB에 날짜관련 매핑 시
    @Temporal(TemporalType.TIMESTAMP)
    private Date createdDate;

    // 마지막에 갱신된 날짜 매핑
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastModifiedDate;

    // DB에 넣지 않는 데이터
    @Transient
    private int temp;
}

(1) @Column

컬럼 속성

(2) @Transient

필드 매핑 ❌
데이터베이스에 저장 ❌, 조회❌
주로 메모리상에서만 임시로 어떤 값을 보관하고 싶을 때 사용

3. 기본 키 매핑 (FK)

직접 할당 or 자동 할당

(1) 직접 할당

@Id 사용
엔티티 클래스의 기본키를 지정할 필드에 @Id 어노테이션을 붙이는 것으로 기본키를 직접 할당
(2) 자동 할당
@GeneratedValue 사용
기본키 생성 전략
- IDENTITY
  - 데이터베이스에 위임
  - @GeneratedValue(strategy = GenerationType.SEQUENCE)
- SEQUENCE
  - 데이터베이스 시퀀스 오브젝트 사용
  - ORACLE, @SequenceGenerator 사용
- TABLE
  - 키 생성용 테이블 사용, 모든 DB에서 사용 가능
  - @TableGenerator
  - 권장 ❌
- AUTO
  - DB 방언에 맞는 SQL 자동 지정
  - auto가 기본값 (오라클, h2, MySQL등에 맞게 자동으로 설정해서 사용)

💡 예시

IDENTITY 예시 : 데이터베이스에서 바로 생성

@Entity
@Getter @Setter
public class Member2 {

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

    @Column(name="name", nullable=false)
    private String username;

}

@SequenceGenerator 사용 예시

@Entity
@Getter @Setter
@SequenceGenerator(name= "MEMBER2_SEQ_GENERATOR",
                    sequenceName = "MEMBER_SEQ",
                    initialValue = 1, allocationSize = 1)
public class Member2 {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE,
                    generator = "MEMBER2_SEQ_GENERATOR")
    private Long id;

    @Column(name="name", nullable=false)
    private String username;

}

[JPA] JPQL, 영속성 컨텍스트

Sun, 30 Apr 2023 14:43:31 GMT

1. 📇 JPQL

JPQL이란?

JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어 제공

JPA는 쿼리를 짤 때 table을 대상으로 쿼리를 짜지 않고 엔티티 객체를 중심으로 개발
- 문제점 : 검색 쿼리, 테이블이 아닌 엔티티 객체를 대상으로 검색
- 모든 DB데이터를 객체로 변환해서 검색하는 것은 불가능
- 애플리케이션이 필요한 데이터만 DB에서 불러오려면 결국 검색조건이 포함된 SQL문이 필요
  해결
  - JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어 제공
  - SQL : 데이터베이스 테이블을 대상으로 쿼리
  - JPQL : 엔티티 객체를 대상으로 쿼리, 객체지향 SQL
    - SQL과 문법이 유사
      - SELECT, FROM, WHERE, GROUP BY, HAVING, JOIN 지원

💡 예시

    List result = em.createQuery("select m from Member as m", Member.class)
                            .setFirstResult(5)    // 5번 부터
                            .setMaxResults(10)  // 10개 가지고 오기
                            .getResultList();

    for(Member member : result) {
        System.out.println("member.name = " + member.getName());
    }

👀 JPA에서 중요한 2가지

1. 객체와 관계형 데이터베이스 매핑(Object Relational Mapping) - ORM

2. 영속성 컨텍스트

(1) 영속성 컨텍스트

JPA를 이해하는 데 가장 중요한 용어

"엔티티(ENTITY)를 영구 저장하는 환경(공간)"이라는 뜻의 논리적인 개념

1) ENTITY

JPA는 데이터와 연관된 객체들을 Entity로 분류하여 관리
따라서 데이터를 읽거나, 조회하거나 쓰는 내용들이 Entity를 통해서 이루어 짐

이러한 엔티티들을 JPA는 어떠한 곳에 저장하는데, 이 영역을 영속성 컨텍스트

2) ENTITY MANAGER

영속성 컨텍스트는 엔티티 매니저를 통해서 접근

JPA는 스레드가 하나 생성될 때 마다(매 요청마다) EntityManagerFactory에서 EntityManager를 생성
EntityManager는 내부적으로 DB 커넥션 풀을 사용해서 DB에 붙음
커넥션 풀에서 커넥션을 꺼내 DB에 데이터를 넣거나 조회하는 작업 등을 수행
persist, findBy와 같은 메소드를 가지고 이 영속성 컨텍스트에서 엔티티들을 꺼내오거나 넣게 됨

EntityManager.persist(entity); cf. em.persist(member); "entity"에 들어가는 객체를 DB에 저장하는 느낌 실제로는 DB에 저장하는 것 ❌ 영속성 컨텍스트에 저장 DB 저장은 tx.commit();에서

3) 엔티티 매니저 vs 영속성 컨텍스트

엔티티 매니저를 통해서 영속성 컨텍스트라는 공간에 접근
DB에 가기전에 어떤 공간을 들러야 하는데 엔티티 매니저로 가능하다는 뜻
영속성 컨텍스트는 논리적인 개념이므로 눈에 보이지는 않는다.
엔티티 매니저와 영속성 컨텍스트는 1:1 대응

(2) 엔티티 생명주기

비영속 (new/transient)

영속성 컨텍스트와 전혀 관계가 없는 새로운 상태

  // 객체를 생성만 한 상태(비영속)
  Member member = new Member();
  member.setId("member1");
  member.setUsername("회원1");

영속 (managed)
- 영속성 컨텍스트에 저장된 상태
- 영속성 컨텍스트에 의해 관리되는 상태
- DB에 저장 ❌ ```java // 객체를 생성한 상태(비영속) Member member = new Member(); member.setId("member1"); member.setUsername("회원1");
  
  EntityManager em = emf.createEntityManager(); em.getTransaction().begin();
  
  // 객체를 저장한 상태(영속) em.persist(member); ``
준영속 (detached)
- 영속성 컨텍스트에 저장되었다가 분리된 상태
```
// 회원 엔티티를 영속성 컨텍스트에서 분리, 준영속 상태
em.detach(member);
em.clear(member);
em.close(member);
```
- .merge() : 분리되었다가 다시 영속성 컨텍스트로
삭제 (removed)
- 삭제된 상태 = 영속성 컨텍스트가 비워진 상태
```
// 객체를 삭제한 상태
em.remove(member);
```
- .persist() : 다시 영속성 컨텍스트로
flush() : 영속성 컨텍스트에서 db에 들어가기 위해사용

3. 영속성 컨텍스트의 장점

애플리케이션과 DB사이에 왜 영속성 컨텍스트가 필요할까?
- 1차 캐시
- 동일성(identity)보장
- 트랜잭션을 지원하는 쓰기 지연(Transactional write-behind)
- 변경감지(Dirty Checking)
- 지연로딩(Lazy Loading)

(1) 1차 캐시

영속성 컨텍스트 내부에 1차 캐시 존재
영속성 컨텍스트 내에 저장되어 있는 값은 별도의 새로운 트랜잭션 없이 1차 캐시 영역 내에서 가져와 트랜잭션을 절약할 수 있음

엔티티를 영속성 컨텍스트에 저장

  Member member = new Member();
  member.setId("member1");
  member.setUsername("회원1");

  // 객체를 영속성 컨텍스트에 저장(영속)
  em.persist(member);

key : @Id로 선언한 필드 값, value : 해당 엔티티 자체로 캐시에 저장

영속성 컨텍스트와 식별자 값

엔티티를 식별자값(@id로 테이블의 기본 키와 매핑한 값)으로 구분

영속 상태는 식별자값이 반드시 있어야 한다.

식별자 값이 없으면 예외 발생

영속성 컨텍스트와 데이터베이스 저장
- JPA는 보통 트랜잭션을 커밋하는 순간 영속성 컨텍스트에 새로 저장된 엔티티를 DB에 반영
- 플러쉬(flush)

이때, find()가 일어난다면?

  Member findMember = em.find(Member.class, "Member1");

⭕ 1차 캐시에 데이터가 있을 때

find()가 일어나는 순간, 엔티티 매니저 내부의 1차 캐시를 먼저 찾음
1차 캐시에 엔티티가 존재하면 바로 반환 -> DB 안 들림

❌ 1차 캐시에 데이터가 없을 때

1차 캐시에 없음 -> DB 들림
DB에서 꺼냄 -> 1차 캐시에 저장 -> MEMBER2 반환
이후에 member2를 조회 -> 1차 캐시에 있는 member2가 반환

(2) 동일성(identity)보장

같은 데이터를 2번 조회할 경우

Member a = em.find(Member.class, "member1");
Member b = em.find(Member.class, "member1");

System.out.println(a == b) // true

같은 호출을 반복해도 1차 캐시에 있는 같은 엔티티 반환하여 동일성을 보장
Mybatis는 동일성 보장이 안됨

(3) 트랜잭션을 지원하는 쓰기 지연(transactional write-behind) - 엔티티 등록

EntityManager em = EntityManagerFactory.createEntityManager();
EntityTransaction tx = em.getTransaction(); // 트랜잭션

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

// 비영속
Member memberA = new Member();
memberA.setId("member1");
memberA.setUsername("홍길동");

Member memberB = new Member();
memberB.setId("member1");
memberB.setUsername("홍길동");

// 영속 : 여기까지 Insert SQL을 데이터베이스에 보내지 않는다
em.persist(memberA);
em.persist(memberB);

// 엔티티 등록 : commit하는 순간 데이터베이스에 Insert SQL을 보냄
tx.commit();

persist()가 일어나면
엔티티들을 1차 캐시에 저장 + 논리적으로 쓰기 지연 SQL 저장소 라는 곳에 INSERT 쿼리들을 저장
DB에 바로 넣지 않고 기다림
commit()할 때, DB에 쿼리들을 보냄
쿼리들을 DB에 보내는 동작이 flush()

여러 개의 엔티티를 생성하고 persist를 하더라도 commit()을 하기 전에는 데이터베이스에 저장❌ --> 쓰기 지연

(4) 변경감지(Dirty Checking)

📌 엔티티 수정 코드

EntityManager em = EntityManagerFactory.createEntityManager();
EntityTransaction tx = em.getTransaction(); // 트랜잭션

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

// 조회 
Member member A = em.find(Member.class, "memberA");
// 영속 엔티티 데이터 수정
memberA.setUsername("hi");
memberA.setAge(10);

// em.update(member); 이런 코드 없이도 update 가능
tx.commit();

엔티티 수정 -> update(), persist() 필요없음
데이터만 set하고 트랜잭션을 커밋하면 자동으로 업데이트 쿼리
HOW? 변경 감지(Dirty Checking)를 통해
persist()로 1차 캐시에 저장할 때 동시에 스냅샷 필드도 저장
commit()또는 flush() 실행 시, 엔티티와 스냅샷을 비교해서 변경사항이있으면 UPDATE SQL을 알아서 만들어서 DB에 저장

4. 플러시

영속성 컨텍스트의 변경내용을 데이터베이스에 반영하는 것

⚡ flush

플러시가 발생하면

변경을 감지(Dirty Checking)
수정된 엔티티를 쓰기 지연 SQL 저장소(transactional write-behind)에 등록
쓰기 지연 SQL 저장소(transactional write-behind)의 쿼리를 데이터베이스에 전송(등록, 수정, 삭제 쿼리)
플러시가 발생한다고 커밋❌ 플러시 다음에 커밋

영속성 컨텍스트를 플러시 하는 법

직접 호출 : em.flush()
자동 호출 : tx.commit()(트랜잭션 커밋), JPQL 쿼리 실행

플러시의 역할

영속성 컨텍스트를 비우지 않음
영속성 컨텍스트의 변경 내용을 데이터베이스에 동기화
플러시가 동작할 수 있는 이유는 데이터베이스 트랜잭션이라는 작업 단위(개념)가 있기 때문 → 커밋 직전에만 동기화하면 됨
JPA는 기본적으로 데이터를 맞추거나 동시성에 관련된 것들은 데이터베이스 트랜잭션에 위임

5. 준영속상태

영속상태
- 1차 캐시에 올라간 상태
- 엔티티 매니저가 관리하는 상태
- em.persist()로 영속성 컨텍스트에 저장한 상태
- em.find()로 조회를 할 때, 영속성 컨텍스트 1차 캐시에 없어서 DB에서 조회해와서 1차 캐시에 저장한 상태
  - 준영속상태
- 영속 상태의 엔티티가 영속성 컨텍스트에서 분리(detached)된 상태
- 영속성 컨텍스트가 제공하는 기능을 사용하지 못함. 쿼리 안나감.

준영속 상태로 만드는 방법

em.detach(entity)
- 특정 엔티티만 준영속 상태로 전환
em.clear()
- 영속성 컨텍스트를 완전히 초기화
- clear는 테스트 케이스 작성시에 도움
em.close()
- 영속성 컨텍스트를 종료

[JPA] JPA 소개

Sat, 29 Apr 2023 18:54:25 GMT

📋 JPA

(1) JPA

Java Persistence API
Java 진영에서 ORM(Object-Relational Mapping) 기술 표준으로 사용하는 인터페이스 모음
자바 어플리케이션에서 관계형 데이터베이스를 사용하는 방식을 정의한 인터페이스
JPA는 자바 표준 interface만을 제공 -> 여러 업체에서 구현체 기술을 만들어놓음
- 인터페이스 = 설계문서
- 설계문서를 구현한 라이브러리(구현체) : eclipseLink, hibernate, dataNucleus 등등...

(2) ORM (Object-Relational Mapping)

객체와 관계형 데이터베이스의 데이터(= RDB(Relational DataBase)의 테이블)를 자동으로 매핑(연결) 해줌
- 기술적으로는 어플리케이션의 객체를 RDB테이블에 자동으로 영속화 해주는 것
- 객체지향 프로그래밍은 클래스를 사용하고, 관계형 데이터베이스는 테이블을 사용한다.
- 객체 모델과 관계형 모델간에 불일치가 존재한다.
- ORM을 통해 객체간의 관계를 바탕으로 SQL을 자동으로 생성하여 불일치를 해결한다.
데이터베이스 데이터 _<-----mapping----->_ object 필드
객체를 통해 간접적으로 데이터베이스 데이터를 다룸
- 객체는 객체대로, RDB는 RDB대로 설계 후
- 그 사이의 불일치는 ORM이 SQL을 자동 생성하여 해결해 준다는 뜻
- JPA는 ORM을 구현한 기술 중 하나 : 객체를 통해 데이터베이스를 조작할 수 있는 API를 제공하는 것

(3) JPA 장단점

1) 장점

① 개발자는 비즈니스 로직을 구성하는데만 집중할 수 있음

SQL문이 아닌 method를 통해 DB를 조작하므로 객체 모델을 이용하여 로직을 구성하면 됨. (내부적으로는 쿼리를 생성하여 DB를 조작함. 하지만 개발자는 이를 신경쓰지 않아도 됨)
② 코드의 가독성을 높임
Query와 같이 필요한 선언문, 할당 등의 부수적인 코드가 줄어들어 각종 객체에 대한 코드를 별도로 작성하여 가독성 높임
③ 객체지향적인 코드 작성이 가능하여 생산성이 증가
매핑하는 정보가 Class로 명시하므로 ERD를 보는 의존도를 낮출 수 잇음
④ 유지보수 및 리팩토링에 유리
기존방식에서 MySql 데이터베이스를 사용하다가 PostgreSQL (대용량 데이터) 로 변환한다고 가정해보면, 새로운 쿼리를 짜야하는 경우가 발생. 이런 경우에 ORM기술을 사용하면 쿼리를 수정할 필요가 없음

2) 단점

① 크고 복잡한 프로젝트의 설계가 잘못되면 속도 저하 및 일관성을 무너뜨리는 문제점 발생

② 결국엔 SQL문을 써야할 수도 있음

복잡하고 무거운 Query는 속도를 위해 별도의 튜닝이 필요하기 때문
③ 학습비용이 비쌈

(4) 데이터베이스 방언

JPA는 특정 데이터베이스에 종속 ❌
각각의 데이터베이스가 제공하는 SQL문법과 함수는 조금씩 다름
- 가변문자 : Oracle varchar2, MySQL varchar
- 문자열을 자르는 함수 : Oracle substr(), SQL표준 substring()
데이터베이스 방언은 그 중 특정 데이터베이스 방언으로 쿼리를 작성하라는 뜻
```
// 오라클 10g 방언으로 사용
  
```
(5) JPA 사용하기

1) JPA dependencies 설정

build.gradle > dependencies에 추가

  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
  runtimeOnly 'com.oracle.database.jdbc:ojdbc8'

프로젝트 생성 시 추가

2) .xml 파일 생성

src/main/resources에 폴더 META-INF생성
META-INF에 persistence.xml 파일 생성

persistence.xml에 추가

3) JPA 사용하기

① @Entity 적용하기

@Entity 어노테이션이 붙은 클래스는 데이터베이스에서 하나의 테이블과 매핑
객체를 관계형 데이터베이스 테이블과 매핑하기 위해 사용

  @Entity
  @Getter @Setter
  public class Member {

      @Id
      private Long id;
      private String name;
  }

② jpa 사용하는 클래스 만들기

엔티티 매니저 팩토리는 하나만 생성해서 애플리케이션 전체에서 사용

transaction : 데이터베이스의 상태를 변화시키기 위해 수행하는 작업 단위

public class JpaMain {

  public static void main(String[] args) {
      EntityManagerFactory emf 
          = Persistence.createEntityManagerFactory("hello");
      EntityManager em = emf.createEntityManager();

      // transaction 선언
      EntityTransaction tx = em.getTransaction();
      // transaction 시작 
      tx.begin();

      try {
          // 추가 
          Member member = new Member();
          member.setId(2L);
          member.setName("UserB");
          em.persist(member);

          // 회원조회
          Member findMember = em.find(Member.class, 1L);
          System.out.println("findMember.id : " + findMember.getId());
          System.out.println("findMember.name : " + findMember.getName());

          // 회원 수정
          findMember.setName("HelloJPA");

          // 회원 삭제
          em.remove(findMember);

          // transaction 커밋
          tx.commit();
          // 커밋과 커밋 사이를 하나의 트랜잭션 단위 = 비즈니스 단위
          // 오류 나면 트랜잭션 자체가 롤백
      }catch (Exception e) {
          tx.rollback();
      } finally {
          em.close();
          emf.close();
      }
  }
}

③ ctrl + f11로 실행 후 디비버에서 테이블 확인

jpa 세팅을 위한 기본 프레임

package com.codingbox.jpa;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
public class Jpabasic {
    public static void main(String[] args) {
        EntityManagerFactory emf 
            = Persistence.createEntityManagerFactory("hello");
        EntityManager em = emf.createEntityManager();        
        EntityTransaction tx = em.getTransaction();
        tx.begin();        
        try {
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
            emf.close();
        }
    }
}

@Entity 있으면 기본 프레임만 실행해도 테이블 생성

[Spring] 필터와 인터셉터

Sat, 29 Apr 2023 17:36:29 GMT

🔒 필터, 인터셉터 사용 예시

로그인된 사람들만 특가를 확인하도록 할 때

모니터링만 할 수 있고 데이터 조작은 안되는 관리자모드 설정 할 때

1. 🧪 필터

(1) 필터 흐름

Http Request -> WAS -> 필터 -> 서블릿 -> 컨트롤러 -> ...
(2) 필터 생성

1) 필터 생성 예시
Filter 인터페이스 상속
로그인이 필요한 url 접속을 위해 로그인 여부를 확인하는 필터 생성

// 필터 인터페이스 구현
public class LoginCheckFilter implements Filter{

    // 화이트리스트 -> 로그인 검증이 필요없음
    private static final String[] whitelist = 
        {"/", "/members/add", "/login", "/logout", "/css/*"};

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        //request, response 생성
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String requestURI = httpRequest.getRequestURI();
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        try {
            System.out.println("인증 필터 체크 시작 : " + requestURI);

            /* whitelist가 아닌 URI만을 검증 */
            if( isLoginCheckPath(requestURI) ) {
                /* session에 값 x -> 단순 url로 들어온 것 
                   미인증 된 사람 = 로그인 안 되어 있는 사람 */
                HttpSession session = httpRequest.getSession(false);
                if( session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null  ) {                    
                    // 로그인창으로 redirect
                    // 예를들어, 내가 로그인 하지 않은 상태로 items url을 접근 
                    // -> 로그인 페이지가 보여져야 한다.
                    httpResponse.sendRedirect("/login?redirectURL="+requestURI);
                    return; // **중요 : 미 인증 사용자는 다음으로 진행하지않고 종료

                }                
            }

            // if문 다음으로 진행
            chain.doFilter(request, response);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("인증 체크 필터 종료 : " + requestURI);
        }


    }

    // whitelist인지 아닌지 체크 : whitelist인 경우 인증 체크 하지 않음
    private boolean isLoginCheckPath(String requestURI) {
        // !를 넣음으로서 whitelist에 없을 때 return하도록
        return !PatternMatchUtils.simpleMatch(whitelist, requestURI);
    }
}

PatternMatchUtils

간단한 패턴 매치 판별해주는 유틸

return !PatternMatchUtils.simpleMatch(whitelist, requestURI);
- 들어온 uri가 whitelist에 있는 지 확인

2) 필터 생성 로직

① private static final String[] whitelist = {"/", "/members/add", "/login", "/logout", "/css/*"};

인증 필터를 적용해도 홈, 회원가입, 로그인화면, css같은 리소스에는 접근가능 해야함
화이트 리스트 경로는 인증과 무관하게 항상 허용
화이트 리스트를 제외한 나머지 보든 경로에는 인증체크 로직을 적용

②isLoginCheckPath(String requestURI)

화이트 리스트를 제외한 모든 경우에 인증 체크 로직을 적용

③ return;

필터를 더이상 진행하지 않는다라는 뜻의 코드
이후 필터는 물론 서블릿, 컨트롤러가 더는 호출되지 않음
앞서 redirect를 사용했기 때문에 redirect가 응답으로 적용되고 요청이 끝

④ httpResponse.sendRedirect("/login?redirectURL="+requestURI);

미 인증된 사용자는 로그인 화면으로 리다이렉트
로그인 이후에 다시 홈으로 이동해버리면, 원하는 경로를 다시 찾아가야 해서 불편함
이를 해소해 주는 코드

/login?redirectURL="+requestURI

사용자가 들어가고 싶어하는 페이지를 파라미터로 로그인 페이지를 열어줌
로그인이 완료된 후 해당 페이지로 넘어가려면 login controller에서 한번 더 처리 필요

@PostMapping("/login")
public String loginv3(@ModelAttribute LoginForm form, 
      Model model, RedirectAttributes redirectAttributes, HttpServletRequest request,
      // @RequestParam(defaultValue = "/") 추가 : 로그인 완료 된 후 사용자가 원하는 페이지로 넘어갈 수 있도록
      @RequestParam(defaultValue = "/") String redirectURL    
      // 파라미터가 없으면 /, 있으면 redirectURL에 넣어줌
      ) {
          ~ 로그인 로직 ~
          return "redirect:" + redirectURL;
      }

jsessionID 숨겨주기 > application.properties에 추가

#jsessionID 노출되지 않도록
server.servlet.session.tracking-modes=cookie

(3) 필터 적용

1) 필터 적용 예시

@Configuration
- class에 적용 시킴으로서 필터 사용
@Bean
- 스프링 컨테이너가 해당 메서드를 빈으로 인식
FilterRegistrationBean : 필터 등록 시 사용
```
//@Configuration
public class WebConfig {
```

// @Bean public FilterRegistrationBean logFilter() { FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean<>();

    filterRegistrationBean.setFilter(new LoginCheckFilter());
    filterRegistrationBean.setOrder(1);
    filterRegistrationBean.addUrlPatterns("/*");

    return filterRegistrationBean;
}

}

### 2) 필터 적용 로직
①```filterRegistrationBean.setFilter(new 필터생성className())```
- 필터 생성한 클래스 이름 불러와서 set
②```filterRegistrationBean.setOrder(1)```
- 필터 적용할 순서
- 1 : 첫번째
③```filterRegistrationBean.addUrlPatterns("/*")```
- 필터 적용할 경로조건
- ```/*``` : 전체 경로 

# 2. 🧪 인터셉터
## (1) 인터셉터
- 서블릿 필터와 같이 웹과 관련된 공통 관심 사항을 효과적으로 해결할 수 있는 기술
- 서블릿 필터가 서블릿이 제공하는 기술이라면, 스프링 인터셉터는 스프링 mvc가 제공하는 기술
- 둘 다 웹과 관련된 공통 관심사항을 처리 but, 적용되는 순서와 범위, 그리고 사용방법이 다름
- 필터보다 인터셉터가 더 디테일한 컨트롤이 가능
## (2) 인터셉터 흐름
![](https://velog.velcdn.com/images/boram_han/post/f6607354-972e-489b-961b-358b9113bfab/image.png)
### 1) 기본 흐름
- HTTP요청 -> WAS -> **필터** -> 서블릿 -> **스프링 인터셉터** -> 컨트롤러
    - 컨트롤러 호출 직전에 호출
    - 디스패처 서블릿 이후에 등장
        - 스프링 MVC가 제공하는 기능이기 때문에
         - 스프링 mvc의 시작점이 디스패처 서블릿
    - 스프링 인터셉터에도 URL패턴을 적용 가능

### 2) 스프링 인터셉터 체인
- HTTP요청 -> WAS -> 필터 -> 서블릿 -> **인터셉터1** ->
**인터셉터2** -> 컨트롤러
  - 스프링 인터셉터는 체인으로 구성
    - 중간에 인터셉터를 자유롭게 추가 가능

## (3) 인터셉터 생성
### 1) 인터셉터 생성 기본 예시
- ```HandlerIntercepter 인터페이스```를 구현
- HandlerIntercepter 인터페이스 **메서드**
  - 서블릿 필터는 ```doFilter()``` 1개, 인터셉터는 3개로 세분화
    - ```preHandle``` : 컨트롤러 호출 전에 호출
      - preHandle의 응답값이 **true**이면 다음으로 진행, **false**면 진행 ❌
      -  **false**인 경우 나머지 인터셉터는 물론이고, 핸들러 어댑터도 호출 ❌
    - ```postHandle``` : 컨트롤러 호출 후에 호출
    - ```afterHandle``` : 뷰가 렌더링 된 이후에 호출

public class LogIntercepter implements HandlerInterceptor{

public static final String LOG_ID = "logId";

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {

    String requestURI = request.getRequestURI();
    String uuid = UUID.randomUUID().toString();

    request.setAttribute(LOG_ID, uuid);

    System.out.println("[intercepter] uuid : " + uuid);
    System.out.println("[intercepter] requestURI : " + requestURI);

    return true; // false로 전환시 진행하지 않음

}

// 컨트롤러 호출 후 modelAndView
@Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("[intercepter] postHandle : " + modelAndView); } // 뷰가 렌더리 된 후 logId, requestURI 출력
@Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    String requestURI = request.getRequestURI();
    String logId = (String)request.getAttribute(LOG_ID);
    // pre에서 해놨던 랜덤 값을 after에서 한번 더 꺼내옴

    System.out.println("[intercepter] logId : " + logId);
    System.out.println("[intercepter] requestURI : " + requestURI);
}

}

### 2) 인터셉터 생성 응용 예시
- 기본적으로 ```preHandle```만 사용

public class LoginCheckInterceptor implements HandlerInterceptor{

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {

    String requestURI = request.getRequestURI();
    System.out.println("[인증 체크 인터셉터 실행] : " + requestURI);
    // 아이디에 대한 정보 session으로 받기
    HttpSession session = request.getSession(false);

    if( session == null || session.getAttribute(SessionConst.LOGIN_MEMBER) == null  ) {
        System.out.println("[미인증 사용자 요청]");
        // 로그인으로 redirect
        response.sendRedirect("/login?redirectURL="+requestURI);
        return false;
    }
    return true;    
}

}

## (4) 인터셉터 적용
### 1) 인터셉터 적용 예시
- ```@Configuration``` : filter와 똑같이 어노테이션 적용
- ```WebMvcConfigurer``` 인터페이스 상속

@Configuration public class WebConfig2 implements WebMvcConfigurer{

    registry.addInterceptor(new LoginCheckInterceptor())
            .order(1)
            .addPathPatterns("/**")     // 모든 경로 전체 가능
            .excludePathPatterns("/", "/members/add", "/login", "/logout", "/css/**"); // 이 경로들을 제외

}

}

### 2) 인터셉터 적용 로직
- ```.addInterceptor(new 인터페이스생성className())```
    - 인터페이스 생성한 클래스 이름 불러와서 add
- ```.order(1)```
    - 인터페이스 적용할 순서
- ```.addPathPatterns("/**")```
    - 구현할 경로
- ```.excludePathPatterns("/css/**", "/*.ico", "/error");```
    - 제외할 경로
> **인터셉터 경로**
> - ```/**```
    - 모든 경로에 대해서 적용할때
    - 예 : ```/css/**```
> - ```/*```
    - 1개의 어떠한 경로에 상관없이 사용, 2번째 경로를 조율하고 싶을 때
    - 예 : ```/*.ico```

[Spring] 쿠키, 세션

Sat, 29 Apr 2023 15:49:54 GMT

🔒 로그인 처리하기 - 쿠키, 세션 사용

1. 🍪 쿠키

(1) 쿠키

쿠키 : 서버에서 전달받은 내용을 사용자 측에서 보관
쿠키의 종류
- 영속 쿠키 : 만료 날짜를 입력하면 해당 날짜까지 유지
- 세션 쿠키 : 만료 날짜를 생략하면 브라우저 종료시 까지만 유지

(2) 로그인 페이지 쿠키 사용

1) 쿠키 생성 후 추가

    // 쿠키 생성
    Cookie idCookie = new Cookie("memberId", String.valueOf(loginMember.getId()));
    // 쿠키 보내기
    response.addCookie(idCookie);
    // 쿠키 생성 후 "/"(home)으로
    return "redirect:/";

2) home화면 로그인 전/후 controll

@CookieValue : 쿠키에 담긴 값 사용
required = false : 쿠키 정보가 없어도 접근 가능 = 로그인 안 한 사용자도 사용 가능

public String homeLogin(
            @CookieValue(name="memberId", required = false) Long memberId, Model model) {

        // 로그인 한 사용자가 아니라면 home으로
        if(memberId == null) {
            return "home";
        }
        // db 조회를 한 후, 사용자가 없으면 다시 home으로 보낸다.
        Member loginMember = memberRepository.findById(memberId);
        if( loginMember == null ) {
            return "home";
        }
        // 로그인에 성공한 사람은 loginHome화면으로 이동        model.addAttribute("member",loginMember);
        return "loginHome";
    }

3) 추가한 쿠키 받아서 로그아웃

expire 메서드 만들기

  private void expireCookie(HttpServletResponse response, String CookieName) {
      Cookie cookie = new Cookie(CookieName, null);
      cookie.setMaxAge(0);
      response.addCookie(cookie);
  }

- expire 메서드 사용
```java
    @PostMapping("/logout")
    public String logout(HttpServletResponse response) {
        expireCookie(response, "memberId");
        return "redirect:/";
    }

2. 📲 session

(1) session

서버에 session이라고 하는 공간에 저장
- cookie : HttpServletResponse
- session : HttpServletRequest
웹 페이지 사용하다 시간이 지나면 자동으로 로그아웃
project > application.properties에 추가
```
   # session time out
   server.servlet.session.timeout=1800
```
- 시간단위 : 초 단위
- 1800 -> 30분
(2) session 옵션
request.getSession(true);
- 세션이 있으면 기존 세션을 반환
- 세션이 없으면 새로운 세션을 생성해서 반환
request.getSession(false);
- 세션이 있으면 기존 세션을 반환
- 세션이 없으면 새로운 세션을 생성하지 않고 null로 반환
request.getSession();
- 신규 세션을 생성하는 request.getSession(true);와 동일

(3) 로그인 페이지 session 사용

1) 세션에서 사용될 상수를 정의해놓은 클래스 만들기

세션에서 로그인한 회원 정보를 저장할 때 사용

오타 발생 가능성을 줄임

  public class SessionConst {
      public static final String LOGIN_MEMBER = "loginMember";
  }

2) 세션 생성

  //세션 생성    
  HttpSession session = request.getSession();
  // 속성 설정
  session.setAttribute(SessionConst.LOGIN_MEMBER, loginMember);
  // 세션 생성 후 "/"(home)으로
  return "redirect:/";

3) 세션 받아서 사용

  // 세션 받기
  HttpSession session = request.getSession(false);
  // 받은 세션 사용
  Member loginMember = (Member)session.getAttribute(SessionConst.LOGIN_MEMBER);

4) 세션 받아서 사용 ② - @SessionAttribute

  @GetMapping("/")
  public String homeLoginv3(
      @SessionAttribute(name=SessionConst.LOGIN_MEMBER, required = false)Member loginMember ,
      Model model)

SessionConst.LOGIN_MEMBER를 key값으로 Member에 할당

5) 세션 삭제

session.invalidate(); 사용해서 세션 삭제

  @PostMapping("/logout")
  public String logoutv2(HttpServletRequest request) {
      // 세션 받아서
      HttpSession session = request.getSession(false);
      if( session != null ) {
          // 세션 삭제
          session.invalidate();
      }
      return "redirect:/";
  }

[Spring] 경로, Redirect

Sat, 29 Apr 2023 10:20:26 GMT

1. 🔀 경로

(1) 일반 경로

/ : 최상위 루트 경로
./ : 현재 위치의 폴더를 의미
../ : 현재 위치의 상단 폴더
💡 예시*
```
   
```
(2) 타임리프로 경로 설정
링크 URL 표현식 @{...} 사용
💡 예시*
th:href
```
  
```
괄호 생략
```
  
```
th:onclick
- |location.href='@{...}'|

2. 🔙 Redirect

(1) Redirect

리퀘스트에 내용을 담지 않고 새로운 요청을 보낼 때 하는 방식

스프링은 redirect:/... 으로 편리하게 리다이렉트를 지원

  @PostMapping("/add")
  public String save5(Item item) {

      itemRepository.save(item);
      return "redirect:/basic/items/" + item.getId();
  }

@PathVariable 값은 redirect에도 사용가능

  @PostMapping("/{itemId}/edit")
  public String editItem(@PathVariable Long itemId, Item item) {
      itemRepository.update(itemId, item);
      return "redirect:/basic/items/{itemId}";
  }

redirect:/basic/items/{itemId}
- @PathVariable Long itemId의 값 그대로 사용

(2) RedirectAttributes

RedirectAttributes를 사용하면 @PathVarialbe 쿼리 파라미터까지도 처리 가능

  @PostMapping("/add")
  public String save6(Item item, RedirectAttributes redirectAttributes) {
      // 객체 Item 저장
      Item savedItem = itemRepository.save(item);

      // addAttribute() 메서드를 사용하여 전달할 파라미터의 이름과 값을 지정
      // 1. 저장된 'Item'객체의 'id'값 사용
      redirectAttributes.addAttribute("itemId", savedItem.getId());
      // 2. status 파라미터의 값은 true로 지정
      redirectAttributes.addAttribute("status", true);
      return "redirect:/basic/items/{itemId}";
  }

주소값 : http://localhost:9091/basic/items/4?status=true

4 ➡ {itemId} : pathVariable로 바인딩

?status=true ➡ redirectAttributes.addAttribute("status", true) : 쿼리 파라미터로 처리

html에서 사용 가능

[Spring] @PostConstruct, @PreDestroy, @ModelAttribute

Sat, 29 Apr 2023 09:21:37 GMT

1. 객체의 초기화, 소멸

(1) 객체의 초기화

@PostConstruct
객체가 생성된 후 별도의 초기화 작업을 위해 실행하는 메소드에 선언
WAS가 띄워질 때 실행됨

테스트용 데이터 생성 예시

    @PostConstruct
    public void init() {
        itemRepository.save(new Item("testA", 10000, 10));
        itemRepository.save(new Item("testB", 20000, 10));
    }

(2) 객체 소멸

@PreDestroy
마지막 소멸 단계에 사용
스프링 컨테이너에서 객체(빈)를 제거하기 전에 해야할 메소드 위에 사용하는 어노테이션

종료 메서드 예시

    @PreDestroy
    public void destory() {
        System.out.println("종료 메서드 호출");
    }

    // 서버 재가동 시 호출됨

2. @ModelAttribute

(1) @ModelAttribute란?

스프링 MVC에서 요청 매핑 메서드
HTTP 요청 파라미터를 컨트롤러의 메서드 파라미터로 전달할 때 사용
요청 파라미터가 객체일 때 편리하게 사용할 수 있다.

(2) 사용 예시

1) @ModelAttribute 없이 사용

파라미터를 직접 가져와서 DTO에 set

//    @PostMapping("/add")
  public String save(
          @RequestParam String    itemName,
          @RequestParam int        price,
          @RequestParam Integer    quantity,
          Model model
          ) {

      Item item = new Item();
      item.setItemName(itemName);
      item.setPrice(price);
      item.setQuantity(quantity);

      itemRepository.save(item);
      model.addAttribute("item", item);

      return "basic/item";
  }

2) @ModelAttribute 사용

파라미터로 넘어온 값을 Item 객체에 set 해주고

그 결과값을 model에 add 해줄 때 키값이 "item" 된다.

  @PostMapping("/add")
  public String save2(@ModelAttribute("item")Item item, Model model) {

      itemRepository.save(item);
      model.addAttribute("item", item);

      return "basic/item";
  }

3) `model.addAttribute("item", item);` 삭제 가능

모델에 @ModelAttribute로 지정한 객체를 넣어주므로 삭제해도 된다.

  @PostMapping("/add")
  public String save2(@ModelAttribute("item")Item item, Model model){    
      itemRepository.save(item);        
      return "basic/item";
  }

4) name 생략 가능

생략시 model에 저장되는 name은 클래스명 첫 글자만

소문자로 등록 경우만 생략 가능

  @PostMapping("/add")
  public String save3(@ModelAttribute Item item) {
      itemRepository.save(item);
      return "basic/item";
  }

5) `@ModelAttribute` 자체 생략 가능

대상 객체는 모델에 자동 등록 됨

  @PostMapping("/add")
  public String save4(Item item) {
      itemRepository.save(item);
      return "basic/item";
  }

[Spring] Lombok 사용

Sat, 29 Apr 2023 06:44:40 GMT

🌶 Lombok

(1) 롬복이란?

롬복은 자바 언어를 사용하는 개발자들을 위한 라이브러리
코드 작성의 반복을 줄여주는 기능들을 제공

(2) 롬복 주요 기능

@Getter 및 @Setter: 객체 필드 생성, getter와 setter를 만들어 줌
@ToString : 객체의 필드를 출력하는 toString() 메서드를 자동으로 생성
@RequiredArgsConstructor :
- final이 붙은 멤버변수만 사용해서 생성자를 자동으로 만들어 줌
- 생성자를 롬복이 자동으로 생성해주기 때문에 코드를 간결하게 작성
@Data :
- @Getter, @Setter, @ToString, @RequiredArgsConstructor 등의 어노테이션을 모두 포함
- 클래스의 모든 필드를 생성하고, 모든 메서드를 만들어 줌

(3) 롬복 사용방법

1) 롬복 의존성 추가

project 생성 시 의존성 추가
build.gradle > dependencies에 의존성 추가
```
  compileOnly 'org.projectlombok:lombok'
  annotationProcessor 'org.projectlombok:lombok'
```
2) cmd창에서 롬복 jar 파일 위치 진입
프로젝트의 Project and External Dependencies에서 lombok-1.18.26.jar 위치 확인
cmd 창에서 jar파일 실행
- cd lombok경로
- java -jar lombok-1.18.26.jar

3) project lombok 실행

cmd에서 jar파일 실행시 다음 화면 켜짐
sts 파일 위치 select
install 성공

4) class 에서 어노테이션 실행

[Spring] 타임리프(Thymeleaf)

Fri, 28 Apr 2023 10:50:39 GMT

🌱 타임리프

(1) 타임리프의 특징

① 서버사이드 HTML 렌더링

타임리프는 백엔드 서버에서 (jsp처럼) HTML을 동적으로 렌더링하는 용도로 사용
② 네츄럴 템플릿
타임리프는 순수 HTML을 최대한 유지
웹 브라우저에서 파일을 직접 열어도 내용을 확인 가능
서버를 통해 뷰 템플릿을 거치면 동적으로 변경된 결과를 확인 가능
③ 스프링 통합 지원
타임리프는 스프링과 자연스럽게 통합
스프링의 다양한 기능을 편리하게 사용할 수 있게 지원

(2) 기본표현식

1) 간단한 표현

${...} : 변수 표현식
*{...} : 선택 변수표현식
#{...} : 메시지 표현식
@{...} : 링크 URL 표현식
~{...} : 조각 표현식

2) 리터럴

텍스트 : 'one text', 'two text', ···
숫자 : 0, 34, 3.0
불린 : true, false
널 : null

3) 문자 연산

문자 합치기 : +
리터럴 대체 : |The Name is ${name}|

4) 산술과 불린 연산

산술 : -, + , - , *, / , %
불린 : and, or , !, not

5) 비교와 동등 연산

비교 : >(gt), <(lt), >=(ge), <=(le)
동등 : ==(eq), !=(ne)

6) 조건 연산

if-then, if-then-else

(3) 텍스트 출력

1) 텍스트 기본 출력

th:text 사용 :
컨텐츠 안에서 직접 출력하기 : [[${data}]]

💡 예시*



   @GetMapping("text-basic")
   public String textBasic(Model model) {
       model.addAttribute("data","Hello spring!!");
       return "basic/text-basic";
   }


    컨텐츠에 데이터 출력하기
    
        th:text 사용 : 
        컨텐츠 안에서 직접 출력하기 = [[${data}]]

**👍 결과**
![](https://velog.velcdn.com/images/boram_han/post/f82d7caf-2e83-4115-a127-ffc1b782e21c/image.png)
### 2) unescaped 태그로 출력
- th:text 사용 : ``````
- inline 방식 : ```[(...)] [(${data})]```
**💡 예시**

@GetMapping("text-unescaped")
public String textUnescaped(Model model) {
    model.addAttribute("data", "Hello Spring!!");
    return "basic/text-unescaped";
}


    text vs utext
    
        th:text =  
        th:utext =  
    

    
        [[...]] vs [(...)]  
    
    
        [[...]] [[${data}]] 
        [(...)] [(${data})]

**👍 결과**
![](https://velog.velcdn.com/images/boram_han/post/7829beb0-f4bc-4629-8786-d006862f4880/image.png)

## (4) 표준 표현식 구문
### 1) Spring EL
#### ① Object
- ```${객체.변수이름}``` : ```"${user.username}">```
- ```${객체['변수이름']}``` : ```${user['username']}```
- ```${객체.get변수이름()}``` : ```${user.getUsername()}```

#### ② List
- ```${리스트이름[i].변수이름}``` : ```${users[0].username}```
- ```${리스트이름[i]['변수이름']}``` : ```${users[0]['username']}```
- ```${리스트이름[i].get변수이름()}``` : ```${users[0].getUsername()}```

#### ③ Map
- ```${맵이름['키값'].변수이름}``` : ```${userMap['userA'].username}```
- ```${맵이름['키값']['변수이름']}``` : ```${userMap['userA']['username']}```
- ```${맵이름['키값'].get변수이름()}```: ```<${userMap['userA'].getUsername()}```

#### ④ 지역변수 사용
- 변수로 리스트 할당
    - th:with 사용 : ``````
- 지역변수 사용
    - 예시 : ``````

**💡 예시**

- **JAVA**

```java
    // 객체 만들기
    public class User {

    private String username;
    private int age;

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public User(String username, int age) {
        super();
        this.username = username;
        this.age = age;
    }

    // controller

    @GetMapping("variable")
    public String textVariable (Model model) {

      User userA = new User("userA", 10);
      User userB = new User("userB", 20);

      List list = new ArrayList<>();
      list.add(userA);
      list.add(userB);

      Map map = new HashMap<>();
      map.put("userA", userA);
      map.put("userB", userB);

      model.addAttribute("user",userA);
      model.addAttribute("users",list);
      model.addAttribute("userMap",map);

      return "basic/variable    
    }

Html


    Spring EL표현식
    Object
        
            ${user.username} = 
        
        
            ${user['username']} = 
        
        
            ${user.getUsername()} = 
        
    
    
        List
        
            ${users[0].username} = 
        
        
            ${users[0]['username']} = 
        
        
            ${users[0].getUsername()} = 
        
    
        
        Map
        
            ${userMap['userA'].username} = 
        
        
            ${userMap['userA']['username']} = 
        
        
            ${userMap['userA'].getUsername()} = 
        
    

    지역변수 - (th:with)
    
    
        
            처음 사람의 이름은

👍 결과

2) 기본 및 편의 객체

기본 객체 : ${#request}, ${#response}, ${#session}, ${#servletContext}, ${#locale}
편의 객체 :
- 리퀘스트 파라미터 : ${#request.getParameter('파라미터 이름')}, ${param.파라미터 이름}
- 세션 : ${session.key값}
- @Component("객체이름") = 스프링 Bean 사용
  - ${@객체이름.메서드이름('파라미터')} : ${@helloBean.hello('user')}

💡 편의 객체 예시

Java

  // 파라미터용 
  

  // 세션용
  @GetMapping("/basic-objects")
  public String basicObjects(HttpSession session) {
      session.setAttribute("sessionData", "hello");
      return "basic/basic-objects";
  }

  // HelloBean.java
  @Component("helloBean")
  public class HelloBean {
      public String hello(String data) {
          return "spring data : " + data;
      }
  }

Html


  편의 객체
  
      
          Request Parameter =         
      

      
          Request Parameter2 =         
      

      
          session =         
              

      
          
          spring bean =

👍 결과*

3) 날짜

기본 표현 : ${localDateTime}
형식에 맞춘 표현 :
- ${#temporals.format(localDateTime, 'yyyy-MM-dd HH:mm:ss')}
- ${#temporals.format(localDateTime, 'yyyy-MM-dd')}
- 이 외 변형해서 사용 가능
디테일한 표현 :
- 년 : ${#temporals.year(localDateTime)}
- 월 : ${#temporals.month(localDateTime)}
- 일 : ${#temporals.day(localDateTime)}
- 요일 : ${#temporals.dayOfWeek(localDateTime)}
- 이 외 변형해서 사용 가능
💡 예시*

Java

  @GetMapping("/date")    
  public String basicDate(Model model) {
      model.addAttribute("localDateTime", LocalDateTime.now());
      return "basic/date";
  }

Html


  LocalDateTime
  
      default = 
      yyyy-MM-dd HH:mm:ss = 
      
      yyyy-MM-dd = 
      
      MM/dd = 
      

  

  LocalDateTime - Utils
  
      ${#temporals.day(localDateTime)} =
          
      
      ${#temporals.month(localDateTime)} =
          
      
      ${#temporals.monthName(localDateTime)} =
          
      
      ${#temporals.monthNameShort(localDateTime)} =
          
      
      ${#temporals.year(localDateTime)} =
          
      

      ${#temporals.dayOfWeek(localDateTime)} =
          
      
      ${#temporals.dayOfWeekName(localDateTime)} =
          
      
      ${#temporals.dayOfWeekNameShort(localDateTime)} =
          
      
      ${#temporals.hour(localDateTime)} =
          
      
      ${#temporals.minute(localDateTime)} =
          
      
      ${#temporals.second(localDateTime)} =
          
      
      ${#temporals.nanosecond(localDateTime)} =

👍 결과*

4) 링크 URL

url 기본
- th:href="@{/hello}"
- 결과 : http://localhost:9090/hello

쿼리 parameter

th:href=@{/hello(param1=${param1}, param2=${param2})}

    @GetMapping("/link")    
      public String basicLink(Model model) {
  model.addAttribute("param1","data1");
  model.addAttribute("param2","data2");
  return "basic/link";
  }

결과 : /hello?param1=data1¶m2=data2
파라미터는 컨트롤러에서 처리

경로 variable
- th:href="@{/hello/{param1}/{param2}(param1=${param1},param2=${param2})}
- 결과 : http://localhost:9090/hello/data1/data2
쿼리 parameter + 경로 variable
- th:href="@{/hello/{param1}(param1=${param1},param2=${param2})}
- 결과 : http://localhost:9090/hello/data1?param2=data2

5) 리터럴

리터럴 : 소스 코드 상에 고정된 값을 말하는 용어
타임리프의 리터럴 : 문자열(String), 숫자(Number), 불리언(Boolean), null
문자 리터럴 1 : 원칙상 항상 ""(큰 따옴표) 안에 ''(작은 따옴표)로 표현
- th:text="'hello' + ' world'"
- th:text="'hello world'"
문자 리터럴 2 : 공백없이 쭉 이어진다면 작은 따옴표를 생략 가능
- th:text="hello"
문자 + data
- th:text="'hello ' + ${data}"
리터럴 대체 : ||를 사용하면 작은 따옴표와 +를 대체할 수 있다.
- "|hello ${data}|"

6) 연산

산술연산
- - 출력 : 12
비교연산
- - 출력 : false
조건식
- "
  - 출력 : 짝수

Elvis 연산자 : 조건식의 축약버전

     @GetMapping("/operation")    
  public String basicOperation(Model model) {
  model.addAttribute("data","Spring");
  model.addAttribute("nullData", null);
  return "basic/operation";
  }

- 출력 : Spring
th:text="${nullData}?:'데이터가 없습니다.'"
- 출력 : 데이터가 없습니다.

No-Operation
- 데이터가 없습니다.
  - 출력 : Spring
- 데이터가 없습니다.
  - 출력 : 데이터가 없습니다.

(5) 속성 값 설정

1) 속성 설정

th:*
- 속성을 지정하면 타임리프는 기존 속성을 th:*로 지정한 속성으로 대체
- 기존 속성이 없다면 새로 생성
  - 결과 : 속성값 name = userA로 설정
    2) 속성 추가
th:attrappend
- 속성 값 뒤에 값을 추가
  - 속성 값 : class="text" -> class="textlarge"
th:attrprepend
- 속성 값 앞에 값을 추가
  - 속성 값 : class="text" -> class="largetext"
th:classappend
- 자연스럽게 추가
  - 속성 값 : class="text" -> class="text large"
    3) check 처리
checked O
checked X
checked = false
👍 결과*

(6) 반복 th:each

1) 기본 반복

💡 예시

Java

  @GetMapping("/each")    
  public String basicEach(Model model) {
      addUsers(model);
      return "basic/each";
  }

  private void addUsers(Model model) {

      List list = new ArrayList<>();

      list.add(new User("userA", 10));
      list.add(new User("userB", 20));
      list.add(new User("userC", 30));

      model.addAttribute("users", list);
  }

Html

👍 결과*

username	age
username	0

2) 반복 상태 유지

반복문에서 두번째 파라미터를 설정해 반복의 상태확인 가능
- 예) count, size, even, true
두번째 파라미터는 생략 가능, 생략하면 지정한 변수명(user) + Stat
- 예) userStat

💡 예시

Html

👍 결과*

count	username	age	etc
			index = count = size = even = odd = first = last =

(7) 조건부 평가

1) if, unless

if : 만약 ~ 한다면
unless : 만약 ~ 하지 않는다면
해당 조건이 맞지 않으면 태그 자체를 렌더링 안 함

💡 예시

Html

  
      
          count
          username
          age

👍 결과*

💡 렌더링 예시

👍 결과

2) switch

조건을 만족하지 않으면 해당 tag가 조회되지 않는다.

💡 예시

Html

👍 결과*

count	username	age
		10살 20살 기타

(8) 기타

1) 주석

① 주석 노출 : 기본 html 주석

② 주석 노출 x : 타임리프 주석

한 줄 주석 :
여러 줄 주석
- 내용
- 2) 블록
반복할 내용을 포함하는 블록(block) 역할
표에 담지 않고도 반복문을 돌릴 수 있다

💡 예시

Html

👍 결과*

3) 자바스크립트 인라인

자바스크립트 영역에 자바스크립트 인라인을 사용하면 타임리프가 관여해 도와줌
① 기본 inline
💡 예시*

Java

  @GetMapping("/javascript")    
  public String basicJavascript(Model model) {
      model.addAttribute("user", new User("userD", 40));
      addUsers(model);
      return "basic/javascript";
  }

Html

👍 결과(페이지 소스보기)*

② 내추럴 템플릿 표기법

/*[[${객체.변수이름}]]*/ "test"

💡 예시

Html

👍 결과(페이지 소스보기)*

③ 객체 담기

JSON 형태로 받아옴

💡 예시

Html
```
      
```

👍 결과(페이지 소스보기)*

④ 자바스크립트 인라인 each

💡 예시*

Html

👍 결과(페이지 소스보기)*

4) 템플릿 레이아웃

th:fragment
- 다른 html에서 해당 html을 사용하고 싶을 때 사용

💡 예시

다른 html에서 copy, copyParam이란 이름으로 해당 html 사용 가능

  
      footer 자리 입니다.
  

  
      파라미터 자리입니다.

① th:insert

💡 예시*
Html
```
  부분 포함 insert
  
    
```

👍 결과(페이지 소스보기)*

   부분 포함 insert
   
       footer 자리 입니다.

② th:replace

💡 예시*
Html
```
  부분 포함 : replace
  
      
```

👍 결과(페이지 소스보기)*

   부분 포함 : replace
   
       footer 자리 입니다.

③ th:replace 단순 표현식

💡 예시*
Html
```
  부분 포함 단순 표현식
  
  
```

👍 결과(페이지 소스보기)*

   부분 포함 단순 표현식
   
       footer 자리 입니다.

④ 파라미터 사용 : th:replace

💡 예시*

   파라미터 사용

👍 결과(페이지 소스보기)*

   파라미터 사용
   
       파라미터 자리입니다.
       데이터1
       데이터2

👍 결과*

[Spring] HTTP 요청 파라미터 & Response view

Wed, 26 Apr 2023 09:10:27 GMT

1. HTTP 요청 파라미터

스프링이 제공하는 @RequestParam, @ModelAttribute을 사용하면 요청 파라미터를 매우 편리하게 이용할 수 있다.
(1) @RequestParam
String, int같은 단순 타입의 파라미터를 받아올 때 사용
파라미터 이름으로 바인딩하는 방법

💡 기본 예시

    @ResponseBody
    @RequestMapping("/request-param-v2")
    public String requestParamV2(@RequestParam("username") String memberName, @RequestParam("age") int memberAge) {
        // 콘솔창에 띄우기
        System.out.println("username : " + memberName);
        System.out.println("age : " + memberAge);
        // 브라우저에 띄우기
        return "ok v2";
    }

📌 @ResponseBody

view조회를 무시하고, HTTP message body에 직접 해당 내용 입력

http://localhost:9090/request-param-v2?username=홍길동&age=17

@RequestParam("username") String memberName
- username으로 파싱해서 String memberName으로 받아옴
- memberName = 홍길동
@RequestParam("age") int memberAge
- age로 파싱해서 int memberAge으로 받아옴
- memberAge = 17

💡 HTTP 파라미터 이름이 변수 이름과 같으면 @RequestParam("XXX") 생략 가능

    @ResponseBody
    @RequestMapping("/request-param-v3")
    public String requestParamV3(@RequestParam String username, @RequestParam int age) {

        System.out.println("username : " + username);
        System.out.println("age : " + age);

        return "ok v3";
    }

@RequestParam("username") String memberName → @RequestParam String username

*💡 String, int 등의 단순 타입이면 @RequestParam도 생략가능 *

    @ResponseBody
    @RequestMapping("/request-param-v4")
    public String requestParamV4(String username, int age) {

        System.out.println("username : " + username);
        System.out.println("age : " + age);

        return "ok v4";
    }

@RequestParam String username, @RequestParam int age → String username, int age

💡 파라미터값에 대한 필수 여부

    @ResponseBody
    @RequestMapping("/request-param-required")
    public String requestParamRequired(@RequestParam(required = true) String username, @RequestParam(required = false) Integer age) {

        System.out.println("username : " + username);
        System.out.println("age : " + age);

        return "ok required";
    }

required = false : 파라미터 누락 가능 required = true : 파라미터 반드시 필요

int등 단순 변수 타입에 null값 ❌ -> wrapper 타입으로 변경 Integer age

💡 defaultvalue : 기본값 세팅

    @ResponseBody
    @RequestMapping("/request-param-default")
    public String requestParamDefault(@RequestParam(required = true, defaultValue = "guest") String username, @RequestParam(required = false, defaultValue = "-1") Integer age) {

        System.out.println("username : " + username);
        System.out.println("age : " + age);

        return "ok defaultValue";
    }

required = true : 파라미터 반드시 필요 defaultValue = "guest" : username 기본값 "guest" defaultValue = "-1" : age 기본값 "-1"

localhost:9090/request-param-default?username=처럼 빈 문자열도 사용가능

(2) @ModelAttribute

String, int같은 단순 타입 외에 사용자 정의 객체 사용 시

💡 기본 예시

객체 생성

public class HelloData {

  private String username;
  private int age;

public String getUsername() {
    return username;
}
public void setUsername(String username) {
    this.username = username;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}

@Override
public String toString() {
    return "HelloData [username=" + username + ", age=" + age + "]";
}

}

```java
    @ResponseBody
    @RequestMapping("/model-attribute-v2")
    public String modelAttributeV2(@ModelAttribute HelloData helloData) {

        System.out.println("username : " + helloData.getUsername());
        System.out.println("age : " + helloData.getAge());
        System.out.println("helloData : " + helloData.toString());

        return "ok hellodata";
    }

@ModelAttribute : 다음의 코드 자동화

        HelloData helloData = new HelloData();
        helloData.setUsername(username);
        helloData.setAge(age);

💡 @ModelAttribute 생략가능

    @ResponseBody
    @RequestMapping("/model-attribute-v3")
    public String modelAttributeV3(HelloData helloData) {

        System.out.println("username : " + helloData.getUsername());
        System.out.println("age : " + helloData.getAge());
        System.out.println("helloData : " + helloData.toString());

        return "ok hellodata3";
    }

@ModelAttribute HelloData helloData → HelloData helloData

2. Response View

💡 뷰 생성





Insert title here


    empty

(1) ModelAndView

💡 사용 예시

    @RequestMapping("/response-view-v1")
    public ModelAndView responseViewV1() {
        ModelAndView mav = new ModelAndView("response/hello")
                                    .addObject("data","hello");
        return mav;
    }

new ModelAndView("response/hello") : 뷰 경로 .addObject("data","hello") : 데이터 담는 곳 "data" : key 값 "hello" : value 값

(2) Model

💡 사용 예시

    @RequestMapping("/response-view-v2")
    public String responseViewV2(Model model) {
        model.addAttribute("data","hello2");
        return "response/hello";
    }

model.addAttribute("data","hello2") : 데이터 담는 곳
"data" : key 값 "hello2" : value 값

💡 @ResponseBody를 사용한다면

    @ResponseBody
    @RequestMapping("/response-view-v3")
    public String responseViewV3(Model model) {
        model.addAttribute("data","hello2");
        return "response/hello";
    }

@ResponseBody ❌ : response/body로 뷰 리졸버가 실행되어서 뷰를 찾고 렌더링 @ResponseBody ⭕ : 뷰 리졸버를 실행하지 않고 , http 메시지 바디에 직접 response/body라는 문자열을 반환

[Spring] 스프링 구조와 의존성

Mon, 24 Apr 2023 18:08:56 GMT

1. 스프링 MVC 구조

🙆‍♀️ 알아두기

파란색 : spring framewor가 관장하는 방식 보라색 : 개발자가 관장하는 부분(MVC 패턴) 초록색 : view = html or jsp 순수 html 사용 비중 증가

① 클라이언트가 request -> 프론트 컨트롤러 역할의 dispatcher servlet은 그 요청을 처리하기 위한 컨트롤러 객체를 검색 ② dispatcher servlet이 직접 컨트롤러를 검색하지 않고 HandlerMapping이라는 빈 객체에게 컨트롤러 검색을 요청

HandlerMapping은 클라이언트의 요청 경로를 이요해서이를 처리할 컨트롤러 빈 객체를 dispatcherservlet에 전달

ex. 웹 요청 경로가 /hello -> 컨트롤러 빈 중 /hello요청 경로를 처리할 controller 리턴

③ dispatcher servlet은 handler mapping이 찾아준 컨트롤러 객체를 처리할 수 있도록 handlerAdapter 빈에게 요청 처리를 위임

④ handlerAdapter는 controller의 알맞은 메서드를 호출해서 요청을 처리

⑤ 컨트롤러 처리 결과를 리턴

⑥ HandlerAdapter로 부터 컨트롤러의 요청 처리 결과를 받으면 dispatcher Adapter는 결과를 보여줄 뷰를 찾기 위해 view resolver 빈 객체 사용 -> view resolver는 이 뷰 이름에 해당하는 view 객체를 찾거나 생성해서 리턴

⑦ dispatcherservlet은 view resolver가 리턴한 view 객체에게 응답 결과 생성을 요청

⑧ view 객체는 웹 브라워에 응답결과를 생성

🙆‍♀️ 알아두기

Model : 사용자가 원하는 데이터나 정보를 제공(db)

dto : 양쪽으로 전송되어 오고가는 데이터들을 담은 객체
dao : 데이터에 접근, 데이터를 관리하기 위한 객체
서비스 : 핵심 비즈니스 로직 구현

View : 보여지는 화면 Controller : 사용자의 요청을 처리하고, 그 요청에 따른 전체적은 흐름을 제어

2. 웹 애플리케이션의 계층 구조

컨트롤러는 서비스의 기능을 사용하며, 서비스에 의존 서비스는 리포지토리의 기능을 사용하며, 리포지토리에 의존

컨트롤러 : http 요청 처리, 웹 MVC의 컨트롤러 역할
서비스 : 핵심 비즈니스 로직 구현
레파지토리 : 데이터베이스에 접근, 도메인 객체를 DB에 저장하고 관리한다.
도메인 : 비즈니스 도메인 객체

3. 의존성

(1) 제어역전

IoC, Inversion of Control
제어의 흐름이 기존에는 개발자가 작성한 코드에서 객체를 생성하고 관리하는 방식에서 프레임워크나 컨테이너로 넘어가게 되는 것
개발자가 프레임워크 기능을 호출하던 것에서 -> 프레임워크가 개발자 코드를 호출
- 제어의 흐름 : 개발자가 작성한 코드 -> 프레임워크
- 개발자 -> 전체를 직접 구현 x, 자신의 코드를 부분적으로 "끼워넣기" 하는 형태로 구현
- 개발자는 비즈니스 로직에 집중 가능
프레임워크 기능
- 객체의 생성, 소멸과 같은 라이프 사이클을 관리
- 스프링으로부터 필요한 객체를 얻어올 수도 있음
- 즉, 프레임워크가 개발자가 작성한 코드를 호출하면서, 필요한 객체를 생성하고, 관리하고, 필요한 때에 호출
💡 예시
- 서비스 객체가 리포지토리 객체를 사용
- 기존 : 서비스 객체가 직접 리포지토리 객체를 생성하고 사용
- 제어 역전 후 :
  - 리포지토리 객체의 생성과 관리를 프레임워크에 맡김
  - 서비스 객체는 직접 리포지토리 객체를 생성하거나 호출하지 않고, 프레임워크에서 제공하는 기능을 이용하여 사용
결론 : 객체의 의존성을 역전 함으로서 객체간의 결합도를 줄이고 유연한 코드를 작성할 수 있게 하여 가독성 강화 및 코드 중복 최소화, 편리한 유지보수 할 수 있게 함

📌 스프링 프레임워크에서 객체를 생성하고 관리하는 곳 : 컨테이너

(2) Spring Container

스프링은 실행 시 객체들을 담고 있는 Container가 존재
- 자바객체 = Bean
- 자바 객체의 생명 주기 관리
  - 개발자는 객체를 생성 소멸할 수 있는 데 스프링 컨테이너가 이 역할을 대신 해줌
  - 즉, 제어의 흐름을 개발자 x -> 프레임워크가 관리
- 생성된 자바 객체들에게 추가적인 기능을 제공
  - 객체들 간의 의존관계를 스프링 컨테이너가 런타임 과정에서 만듦

(3) MemberController

생성자에 @Autowired -> 스프링이 연관된 객체를 스프링 컨테이너에서 찾아서 넣어줌
객체 의존관계를 외부에서 넣어주는 것을 DI(Dependecy Injection) = 의존성 주입
이전에는 개발자가 직접 주입 -> 현재, @Autowired에 의해 스프링이 주입

📌 @Autowired

필요한 의존 객체의 "타입"에 해당하는 빈을 찾아 주입
기본값이 true이기 때문에 의존성 주입을 할 대상을 찾지 못한다면 애플리케이션 구동에 실패

📌 POJO

Plain Old Java Object, 단순한 자바 오브젝트
객체 지향적인 원리에 충실하면서 환경과 기술에 종속되지 않고 필요에 따라 재활용될 수 있는 방식으로 설계된 오브젝트

(4) 컴포넌트 스캔의 대상

Component Scan
- 어노테이션을 사용하여 스프링에서 관리하는 Bean으로 등록
- 자동으로 이루어지며 스프링 컨테이너가 지정된 패키지에서 모든 클래스를 검색하고, 스프링에서 관리하는 Bean으로 등록
컴포넌트 스캔의 대상
- main메서드가 있는 class의 동일 패키지 또는 하위 패키지만 spring이 scan
  - 예를 들어, main 메서드가 있는 클래스가 "com.example" 패키지에 있다면, "component scan"은 "com.example" 패키지와 그 하위 패키지에서만 검색을 수행
- @Component, @Controller, @Service, @Repository 등이 지정된 클래스를 검색하여 Bean으로 등록

⭐ (5) 의존성 주입 방법

의존성 주입(Dependency Injection, DI) : 제어역전을 구현하는 방법
객체간의 의존성을 낮추기 위해 외부에서 필요한 객체를 주입받는 방식

① Field Injection (필드 주입)

- 순환참조 때문에 권장 x

    @Autowired 
    private MemberRepository memberRepository;

② Setter Injection (수정자 주입)

- 바뀔(수정될) 가능성이 있으므로 사용 x

    private MemberRepository memberRepository;

     @Autowired
     public void setMemberRepository(MemberRepository memberRepository) {
             this.memberRepository = memberRepository;
      }

③ Constructor Injection (생성자 주입)

- 가장 많이 사용되는 방법

    private final MemberRepository memberRepository;

    @Autowired
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }


    // 현재 클래스에서만 접근 가능하도록 막아두기
    // 의존 관계가 한번 만들어지면 아예 수정이 불가능한 상태로 만들어주기

⭐ 4. SOLID

SOLID : 클린코드로 유명한 로버트 마틴이 정리한 좋은 객체 지향 설계의 5가지 원칙을 정리
스프링 프레임워크는 SOLID 원칙을 지키도록 하여, 유지보수, 확장성, 재사용성, 테스트 용이성 등을 보장하며, 객체지향적으로 프로그래밍하는 데 도움을 줌
- SRP : 단일 책임 원칙 (Single responsibility principle)
- OCP : 개방-폐쇄 원칙 (Open-closed principle)
- LSP : 리스코프 치환 원칙 (Liskov substitution principle)
- ISP : 인터페이스 분리 원칙 (Interface segregation principle)
- DIP : 의존관계 역전 원칙 (Dependenct inversion principle)

(1) SRP : 단일 책임 원칙

한 클래스는 하나의 책임만
하나의 책임이라는 것은 모호
- 클 수도 있고, 작을 수도
- 문맥과 상황에 따라 다름
어떻게 하는 게 설계가 잘 된건지 중요한 판단 기준은 변경
변경이 있을 때 파급효과가 적으면 단일 책임 원칙을 잘 따른 것
EX) ui 변경할 때 하나 바꾸면 다른 거 다 바꿔야 하는 것 ❌

(2) OCP : 개방-폐쇄 원칙

클래스가 확장에는 열려있고, 수정과 변경에는 닫힘
수정과 변경은 오류를 야기할 수 있으므로

기존 코드 변경 없이 코드 확장하는 법

1. 다형성 활용 인터페이스를 구현한 새로운 클래스를 하나 만들어서 새로운 기능을 구현 -> 기존 코드 변경 x 2. 스프링 활용 객체를 생성하고, 연관관계를 맺어주는 별도의 조립, 설정자 = 스프링

(3) LSP : 리스코프 치환 원칙

프로그램의 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위타입의 인스턴스로 바꿀 수 있어야 함
다형성에서 하위클래스는 인터페이스 규약을 다 지켜야 함
- 인터페이스를 구현한 구현체를 믿고 사용하려면, 이 원칙이 필요
- 단순히 컴파일에 성공하는 것을 넘어서 이야기
  
  EX. 악셀 구현 -> 악셀은 앞으로 가야함 BUT, 뒤로 가게 구현 한다면? 컴파일 오류는 없음 -> BUT, 인터페이스 규약이 깨짐 -> 인터페이스 규약을 지켜줘야됨

(4) ISP : 인터페이스 분리 원칙

특정 클라이언트를 위한 인터페이스 여러개가 범용 인터페이스 하나보다 나음
인터페이스가 명확해지고, 대체 가능성이 높아짐

EX. 자동차 인터페이스 -> 운전 인터페이스, 정비 인터페이스로 분리 인터페이스를 분리하면 정비 인터페이스 자체가 변해도 운전 인터페이스는 영향을 주지 않는다.

(5) DIP : 의존관계 역전 원칙

프로그래머는 추상화에 의존해야지 구체화에 의존하면 ❌
의존성 주입은 이 원칙을 따르는 방법 중 하나
즉, 구현 클래스에 의존하지 말고 인터페이스에 의존할 것

EX. 운전자가 자동차역할에 대해 잘 알아야지 k3, 테스라 각각에 집중하면 운전이 힘들어 짐

[Spring] 스프링 개요

Wed, 19 Apr 2023 16:39:39 GMT

1. Framework vs Library

(1) Framework

'뼈대나 근간'을 이루는 코드들의 묶음
프로그램의 기본 흐름이나 구조를 정하고, 이 구조에 자신의 코드를 추가하는 방식으로 개발할 수 있도록 하는 프로그래밍의 기본 틀을 의미
개발에 필요한 구조가 제공되고, 여기에 필요한 부분을 조립하는 형태로 개발이 진행된다.

(2) Library

자주 사용되는 로직을 재사용하기 편리하도록 잘 정리한 일련의 코드들의 집합

(3) Framework vs Library

프레임워크는 자동차의 프레임, 즉 기본적으로 구성하고 있는 뼈대 -> 바꿀 수 없음
라이브러리는 자동차의 기능을 하는 부품을 의미
쉽게 바꿀 수 있음
스프링 프레임워크 : 이미 여러 라이브러리들이 장착돼 있음

2. Spring

(1) 스프링 프레임워크

스프링 프레임워크는 자바 플랫폼을 위한 오픈소스 애플리케이션 프레임워크
동적인 웹 사이트를 개발하기 위한 여러가지 서비스를 제공
스프링 사용방법

(2) 스프링 사용하기

1) sts 다운받기
sts : spring-tool-suite
sts 다운
압축파일 풀어서 툴 사용하기

2) spring 프로젝트 만들기

스프링 프로젝트 만들기

프로젝트 옵션
- Project : 빌드 툴 (프로젝트에 필요한 의존성을 관리하는 툴) 선택
  - 과거에는 Maven
    - xml 방식으로 작성
    - depency 태그로 라이브러리 복붙
    - 매번 정확한 버전을 입력해줘야 함
  - 최근에는 Gradle
    - 주소 복붙으로 가능
    - 매번 정확한 버전을 입력해줄 필요 없음
    - 더 직관적
- Spring Boot : 사용할 버전 선택
  - SNAPshot : 개발중인 버전
  - M2 : 베타버전 ( 버그테스트 중)
- Group : 회사의 identity
- artifact : 프로젝트 이름
- Packaging : 스프링부트는 웬만하면 jar로 배포
- Dependencies : 프로젝트 생성과 동시에 사용할 라이브러리
  - spring web : 별도 설치 없이 톰캣, 서블릿 사용 가능
  - thymeleaf : jsp 대신 사용할 라이브러리
generate로 프로젝트 생성
사용할 workplace에서 프로젝트 zip 풀기

3) eclipse에서 프로젝트 사용

① import 하기

② html 파일 불러올 수 있는 환경 만들기

eclipse marketplace 들어가기

순서대로 눌러주기

③ application.properties 사용해서 환경설정하기

src/main/resources의 application.properties에서 환경설정 가능함
port 수정

server.port=9090

한글에 대한 기본 세팅

spring.http.encoding.charset=UTF-8
spring.http.encoding.enabled=true
spring.http.encoding.force=true

타임리프 설정

spring.thymeleaf.cache=false
// 새로고침으로 타임리프 변경사항 웹에서 확인 가능

④ build.gradle 이용하면 원하는 라이브러리 추가 생략 가능

⑤ 타임리프 템플릿 추가

앞으로 사용할 html에 타임리프를 계속 사용하기 때문에 매번 선언해주는 번거로움 방지

(3) 주요 어노테이션과 기능

1) 주요 어노테이션

① 스프링 시작점

@SpringBootApplication
- 스프링 부트의 자동 설정 읽기와 생성이 모두 자동으로 설정
- src/main/java > CoreApplication.java 파일 내에 자동 위치
  ② Spring MVC
@Controller : 해당 url mapping을 찾는 역할
@GetMapping/@PostMapping : url get방식/post방식 요청 매핑
@RequestMapping : 방식에 상관없이 요청 매핑

③ 파라미터 값 받는 어노테이션

@RequestParam
- @RequestParam("name") : 기본 name이라는 key값을 파싱, 옵션 추가 가능
  - required : 파라미터 값 필수 여부
    - true -> 필수(default) , false -> 필수 x
  - defaultValue : 파라미터 값이 없을 경우, 기본으로 들어갈 값

💡 예시

<>

@GetMapping("/hello-mvc")
public String helloMvc(@RequestParam(value = "name", required = false, defaultValue = "required value") String name, Model model) {
    model.addAttribute("name", name);
    return "hello-template";
}

<>






Insert title here


    Hello empty

👍 결과

🙆‍♀️ 알아두기

컨트롤러에서 리턴값으로 문자를 반환하면 resources/templates/ + {viewName} + .html -> 뷰 리졸버(viewResolver)

💡 예시



@Controller
public class HomeContoller {

    // localhost:9090으로 호출하면 home() 호출
    @GetMapping("/")
    public String home() {
        return "home";
    }
}







Insert title here


    home 출력 테스트

👍 결과 localhost:9090으로 호출하면 home.html 파일 출력

2) 주요 기능

① ViewResolver (뷰 리졸버)

실행할 뷰를 찾음
페이지 컨트롤러가 리턴한 뷰 이름에 해당하는 뷰 객체를 매핑하는 역할
② DispatcherServlet
스프링 MVC도 프론트 컨트롤러 패턴으로 구현되어 있다.
스프링 MVC의 프론트 컨트롤러가 바로 디스패처 서블릿이다.
DispatcherServlet -> FrameworkServlet -> HttpServletBean -> HttpServlet 상속받고 있음

(4) Model

1) Model

Controller에서의 데이터를 Model에 담음
View는 Model에 담겨 있는 데이터만 쏙쏙 골라서 화면에 바인딩
HashMap의 형태를 갖고 있고, Key와 value값을 저장
servlet에서 request.setAttribute()와 비슷한 역할

💡 예시

@Controller
public class MemberController {

    // member url mapping
    @RequestMapping("member")
    public String getMember(Model model) {

        MemberDTO member = new MemberDTO( 1, "자바학생", "01012345678");
        model.addAttribute("member",member);
        return "thymeleaf/member";
        // templates 파일 밑에 thymeleaf 밑에 member.html
    }    
}

2) ModelAndView

model에서 view의 영역이 좀 더 확장
Model과 View를 동시에 설정이 가능하려면 컨트롤러는 ModelAndView객체만 리턴하지만 Model과 View가 모두 리턴 가능
- addObject(key, value) : 데이터 설정
- setViewName("경로") : 뷰 설정

boram.log

[Cs Project] 동기 vs 비동기

동기 vs 비동기

동기 비동식 방식을 알아야 하는 이유

동기식

비동기식

블로킹 vs 논블로킹

블로킹

논블로킹

조합

조합 예시

동기-블로킹

동기-논블로킹

비동기-블로킹

비동기 - 논블로킹

마지막 정리

출처

[Spring] 프로젝트 실전 ② - validation check

1. Name 입력 여부

(1) 라이브러리 추가

(2) @NotEmpty 추가

(3) @Valid 추가

(4) input box에 에러 메세지 담기

① 에러여부에 따라 class명 바꾸기

② @NotEmpty(message = "회원 이름은 필수입니다.")불러오기

2. Name 중복 여부

(1) @service에서 repository.save가 실행되기전에 메서드 추가

(2) 메서드 만들기

(3) 예외 처리 : 메서드, 메서드 호출하는 곳, 서비스랑 연결된 곳

[Spring] 프로젝트 실전 ①

1. 오류 확인하기 - Logger

3. 프로젝트에서 JPA 사용

4. Service 클래스 - @transactional

(1) @transactional

(2) @transactional 옵션

5. embedded 객체 타임리프로 받아오기

[Spring] ENUM

📋 ENUM

(1) ENUM이란

(2) ENUM의 장점

(3) ENUM과 메모리 구조

(4) ENUM 사용

1) 단순 열거

2) 이름과 값 부여

3) JPA에서 사용

[JPA] JPQL

💻 JPQL

1. JPQL

2. JPQL 사용하기

(1) 사용 기본

① 대소문자 구분

② 엔티티 이름

③ 별칭은 필수(알리야스)

(2) JPQL 문법

(3) 반환 타입 지정

(4) 결과 조회

(5) 파라미터 바인딩

(6) 프로젝션

(7) 페이징 API

(8) 조인

(9) 서브 쿼리

[JPA] 값 타입

💱 값 타입

(1) 엔티티 타입 vs 값 타입

◾ 엔티티 타입

◾ 값 타입

(2) 값 타입

1) 기본값 타입

2) 임베디드 타입

(3) 임베디드 타입(EMBEDDED TYPE)

1) JPA에서 임베디드 타입 사용법

2) 임베디드 타입의 장점

3) 임베디드 타입과 테이블 매핑

4) @AttributeOverride : 속성 재정의

5) 객체 타입의 한계

[Spring] YamL

☘ Yaml (설정파일 *.yml)

(1) properties vs yml

(2) 주의사항

[JPA] 연관관계 매핑