스프링의 정석 Ch2. 02 Spring MVC

👏🏻

01. 원격 프로그램의 실행

로컬 프로그램 실행

원격 프로그램 실행

실행 방법

❓URL와 연결한 메서드가 private임에도 호출이 가능한 이유가 무엇일까?

❓URL와 연결하는 메서드는 왜 인스턴스 메서드로 선언하는 걸까?

02. AWS에 배포하기

03~04. HTTP 요청과 응답

HttpServletRquest

HttpServletRquest의 메서드

클라이언트와 서버

서버의 종류

서버의 포트

WAS(웹 애플리케이션 서버)란?

Tomcat의 내부 구조

Tomcat의 설정 파일 - server.xml, web.xml

HTTP 요청과 응답

1. 프로토콜(protocol)이란?

2. HTTP(Hyper Text Transfer Protocol)란?

3. HTTP 메시지

HTTP 메시지 - 응답 메시지

HTTP 메시지 - 요청 메시지

HTTP 메서드 - GET, POST

텍스트 파일 VS 바이너리 파일

8. MIME(Multipurpost Internet Mail Extensions)

9. Base64

2. 공통 코드의 분리 - 입력의 분리

3. 출력(view)의 분리 - 변하는 것과 변하지 않는 것의 분리

4. MVC 패턴

+) 실습

5. ModelAndView

6. 컨트롤러 메서드의 반환타입

+) MVC 패턴의 원리

13~16. 서블릿과 JSP

1. 서블릿과 컨트롤러의 비교

2. 서블릿의 생명주기

❓서블릿은 Singleton인데 여러 사용자가 동시에 같은 요청을 동시에 보내도 가능한 이유?

4. JSP와 서블릿의 비교

5. JSP의 호출 과정

6. JSP와 서블릿으로 변환된 JSP 비교

7. JSP의 기본 객체

8. 유효 범위(scope)와 속성(attribute)

1. pageContext

2. application

3. session

4. request

5. page, request, session, application 정리

9. URL 패턴

10. EL(Expression Language)

11. JSTL(JSP Standard Tag library)

2. Filter

17~18. @RequestParam과 @ModelAttribute / RequestMapping

1. @RequestParam

❓입력되는 값이 year, month, day인데 전혀 관계 없는 타입의 MyDate를 선언해도 이걸 다 알아서 넣어준다고?

2. @ModelAttribute

컨트롤러의 매개변수에 붙이는 애너테이션

3. WebDataBinder

역할

01. 원격 프로그램의 실행

로컬 프로그램 실행

원격 프로그램 실행

= 다른 사람의 컴퓨터에 있는 프로그램 실행

실행 방법

서버에 있는 원격 프로그램을 실행하기 위해서는 브라우저와 WAS가 필요하다.

브라우저에서 http://111.222.333:8080의 URL 주소로 요청을 보내면,

톰캣에서 원격으로 프로그램(메서드)을 실행시키게된다.

아무 프로그램이나 원격 실행이 가능한 것은 아니다.

💡

1. 원격 호출이 가능한 프로그램 등록(@Controller)
2. URL과 메서드를 연결(@RequestMapping)

@Controller // 1. 원격 프로그램으로 등록(AC의 빈으로 등록)
public class Hello {
	
	@RequestMapping("/hello") // 2. URL과 main()을 연결 / 이게 중요한 거임
	private void main() { // 이름은 아무거나 상관없음
		System.out.println("Hello");
	}
}

http://111.222.333.444:8080/ch2/hello 를 호출하면 hello와 연결된 메서드가 호출된다.

❓URL와 연결한 메서드가 private임에도 호출이 가능한 이유가 무엇일까?

RequestMapping은 외부에서

→ 스프링 프레임워크가 자바의 Reflection API를 이용해서 객체를 생성해 메서드를 호출하기 때문에 가능하다.

• 예제

  package com.fastcampus.ch2;
  
  import java.lang.reflect.Method;
  
  public class Main {
      public static void main(String[] args) throws Exception {
  //        Hello h = new Hello();
  //        h.main(); // main()은 private라서 외부 호출 불가
  
          // 아까는 Reflection API(클래스 정보를 얻고 다룰 수 있는 강력 기능 제공)를 사용했기 때문에 호출이 가능했던 것이다.
          // java.lang.reflect 패키지 제공
  
          // Hello 클래스의 Class 객체(클래스의 정보를 담고 있는 객체) 얻어온다.
          // 클래스 파일(*.class)이 메모리에 올라갈 때, 클래스 파일마다 Class 객체가 하나씩 생성된다.
          Class helloCass = Class.forName("com.fastcampus.ch2.Hello");
          Hello hello = (Hello) helloCass.newInstance(); // Class 객체가 가진 정보로 객체 생성
          Method main = helloCass.getDeclaredMethod("main"); // main() 메서드의 정보를 가지고온다.
          main.setAccessible(true); // private인 main()을 호출 가능하게 한다.
  
          main.invoke(hello); // hello.main()과 동일
      }
  }

❓URL와 연결하는 메서드는 왜 인스턴스 메서드로 선언하는 걸까?

→ static 메서드는 iv를 사용할 수 없기 때문

+) URL로 원격 프로그램 호출 시 톰캣이 객체 생성을 해 준다. 그 다음에 메서드 호출이 된다.

• 예제

  package com.fastcampus.ch2;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  // 1. 원격 호출가능한 프로그램으로 등록
  @Controller
  public class Hello {
  	int iv = 10; // 인스턴스 변수
  	static int cv = 20; // static 변수
  	@RequestMapping("/hello") // 2. URL과 main()을 연결
  	public void main() { // 인스턴스 메서드 - iv, cv를 둘 다 사용 가능
  		System.out.println("Hello - private");
  		System.out.println(cv);
  //		System.out.println(iv);
  	}
  	// 인스턴스 메서드와 스태틱 메서드의 차이는 iv 사용 여
  
  	public static void main2() { // static 메서드 - cv만 사용 가능
  		System.out.println(cv); // OK
  //		System.out.println(iv); // 에러 static 메서드는 인스턴스 멤버 사용 불가능
  	}
  }

02. AWS에 배포하기

프로젝트 war 파일로 추출 : Build > Build artifacts

13.124.20.48:8080/ch2/Hello

원격 서버에 접속하기

03~04. HTTP 요청과 응답

HttpServletRquest

@Controller // 1. 원격 호출이 가능한 프로그램으로 등록
public class RequestInfo {
    @RequestMapping("/requestInfo") // 2. URL과 main()을 연결
    public void main(HttpServletRequest request) {
        System.out.println();
    }
}

1. http://localhost/requestInfo?bno=3 URL 입력 후 호출 시

2. 톰캣이 HttpServletRequset 객체를 만든다.

3. 거기에 요청한 정보를 담는다.

4. 톰캣이 main 메서드의 매개변수로 알아서 넘겨준다.

요청에 대한 정보가 필요하면 메서드의 매개변수로 HttpServletRequest만 적어주면 된다. 그럼 스프링이 알아서 매개변수에 해당하는 객체나 값을 넘겨준다. request 참조변수를 통해서 우리가 원하는 정보를 얻어올 수 있다.

• 이해를 돕기위한 YoilTeller.java 예제

  terminal에서 java YoilTeller 2021 10 1로 호출하면 자바 인터프리터가 배열에 2021, 10, 1 값들을 String 배열에 담아서 main 메서드의 매개변수에 넘겨준다.

  이처럼 요청한 정보를 톰캣이 객체를 만들고 담아서 넘겨주는 것이다. 우리는 단순히 그걸 사용하면 되는 것이다.

  package com.fastcampus.ch2;
  
  import java.util.Calendar;
  
  // 년월일을 입력하면 해당 날짜가 어떤 요일인지 알려주는 프로그램
  public class YoilTeller {
      public static void main(String[] args) {
          // 1. 입력
          String year = args[0];
          String month = args[1];
          String day = args[2];
  
          int yyyy = Integer.valueOf(year);
          int mm = Integer.parseInt(month);
          int dd = Integer.parseInt(day);
  
         // 2. 작업
          Calendar cal = Calendar.getInstance();
          cal.set(yyyy, mm - 1, dd);
  
          int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); // 1 : 일요일, 2 : 월요일
          char yoil = " 일월화수목금토".charAt(dayOfWeek);
  
          // 3. 출력
          System.out.printf("%d년 %d월 %d일은 ", yyyy, mm, dd);
          System.out.println(yoil + "요일입니다.");
      }
  }

HttpServletRquest의 메서드

?year=2021&month=10&day=1

// URL 자체가 문자열이기 때문에 문자열로 받도록 되어있다.
String year = request.getParameter("year");
String year = request.getParameter("year");
String month = request.getParameter("month");
String day = request.getParameter("day");

깊게X, 알아만두기

위의 YoilTeller.java를 원격 호출이 가능한 프로그램으로 변경한 예제

• YoilTeller.java

  http://localhost:8080/ch2/getYoil?year=2002&month=1&day=15

  package com.fastcampus.ch2;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.util.Calendar;
  
  // 년월일을 입력하면 해당 날짜가 어떤 요일인지 알려주는 프로그램
  // 1. 원격 호출이 가능한 프로그램으로 변경
  @Controller
  public class YoilTeller {
  //    public static void main(String[] args) {
      @RequestMapping("/getYoil") // 2. URL과 메서드 연결
      public void main(HttpServletRequest request, HttpServletResponse response) throws Exception {
          // 1. 입력
          String year = request.getParameter("year");
          String month = request.getParameter("month");
          String day = request.getParameter("day");
  
          int yyyy = Integer.valueOf(year);
          int mm = Integer.parseInt(month);
          int dd = Integer.parseInt(day);
  
         // 2. 작업
          Calendar cal = Calendar.getInstance();
          cal.set(yyyy, mm - 1, dd);
  
          int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); // 1 : 일요일, 2 : 월요일
          char yoil = " 일월화수목금토".charAt(dayOfWeek);
  
          // 3. 출력
          System.out.printf("%d년 %d월 %d일은 ", yyyy, mm, dd);
          System.out.println(yoil + "요일입니다.");
  
          // 이렇게 하는 이유는 브라우저는 내가 보내는 내용이 텍스트인지 바이너리인지 모르기 때문이다.
          response.setContentType("text/html");
          response.setCharacterEncoding("utf-8"); // 이게 없으면 한글 깨진다. 우리가 보내는 텍스트 인코딩이 무엇인지 알려줘야 브라우저가 해석 가능
  
          PrintWriter out = response.getWriter(); // response 객체에서 브라우저로의 출력 스트림을 얻는다.
          out.printf("%d년 %d월 %d일은 ", yyyy, mm, dd);
          out.println(yoil + "요일입니다.");
      }
  }

클라이언트와 서버

💡

클라이언트(client) : 서비스를 요청하는 애플리케이션

서버(server) : 서비스(service)를 제공하는 애플리케이션

서버의 종류

서버의 종류는 어떤 서비스를 하느냐에 따라 달라진다.

이메일 서버 : 이메일 서비스 제공

파일 서버 : 파일 제공

웹 서버 : 웹 제공?❌ 브라우저를 통해서 받을 수 있는 모든 서비스를 제공(문서, 이미지, 동영상 모두 웹서버가 제공하는 서비스다.)

서버의 포트

1대의 PC에 서버 프로그램이 여러 개 존재할 수 있다.

클라이언트가 IP로 요청 시 한 대의 PC에 여러 개의 서버가 존재하기 때문에 어떤 서버에 대한 요청인지 IP로만으론 구분을 하지 못한다.

이때 필요한 것이 포트 번호다. 포트 번호를 적어서 클라이언트가 요청을 하면 한 대의 PC중 어떤 서버에 요청을 보내는 건지 알 수 있다.

WAS(웹 애플리케이션 서버)란?

💡

웹 애플리케이션 서버(WAS) : 웹 애플리케이션을 서비스하는 서버

Web Server : Web을 서비스

Web Application Server : Web Application을 서비스 → Application을 서비스 → 애플리케이션 = 프로그램. WAS는 서버에 프로그램을 설치해놓고 클라이언트가 이 프로그램을 사용할 수 있게 해주는 것이다.

우리가 만든 프로그램은 클라이언트가 원격 호출한다.

옛날에는 PC마다 각각 다 프로그램을 설치했어야 했다. 그런데 Client에게 설치하지 않고 Server에만 설치하면 한 군데만 업데이트하면 된다. 이런 업데이트의 용이성 때문에 WAS를 사용한다.

Tomcat의 내부 구조

Thread Pool : 쓰레드들을 미리 만들어두었다가 요청이 오면 이 중에 하나의 쓰레드가 맡아서 요청을 처리한다.

+) 미리 쓰레드를 만들어놓으면 그때그때 만들 필요 X, 요청이 오면 한가한 쓰레드가 처리한다.

Server(Tomcat)안에 Service가 있고 Service안에 실제로 서비스를 처리하는 Engine이 있다.

Connector

어떤 protocol로 요청했냐에 따라 처리할 Connector가 달라진다.

Connector(HTTP1.1)은 Engine에게 요청을 전달한다.(서버가 Tomcat이면 Engine이름이 Catalina)

Engine

Host

Engine 안에는 Host가 있다. 보통은 하나지만 하나의 톰캣 안에 여러 개의 호스트가 존재할 수 있다.(n개의 호스트 가능)

Domain Name이 다른 여러 개의 Host를 설치할 수 있다.

Context

Host 안에는 Context가 있는데 여러 개 존재 가능하다.

Context = 하나의 웹 애플리케이션

ex) /ch2, /ch3 이렇게 여러 개의 컨텍스트가 Host 안에 있을 수 있다.

하나하나가 웹 애플리케이션(쉽게 intelliJ 프로젝트), 서로 영향을 주지 않는 독립적인 공간에서 돌아간다.

Servlet

Context 안에 서블릿이 존재한다. 서블릿은 작은 서버 프로그램이라는 뜻이다.

컨트롤러 = 서블릿 / 둘 다 서버 프로그램

요청 URL이 /event/list면 event 컨텍스트에 해당하는 list와 연결된 서블릿이 실행된다.

<정리>

Tomcat Server안에 Service가 있고 그 Service를 처리하는 게 Engine

Engine 안에는 Host가 여러 개 있을 수 있고 Host안에도 Context가 여러 개 있을 수 있다.

Context = Spring Project, 그 안에 있는 프로그램이 Servlet

• 이해를 돕기 위한 위에서 설명한 과정 살펴보기

  쓰레드가 여러개 있는데 그 중에 하나가 요청을 받아서 처리한 것

  

  호출스택이 아래부터 쭉 쌓인 건데 제일 아래 run부터 시작한 것을 확인할 수 있다.

  

  이 요청을 HTTP 1.1 Prosessor가 처리

  가볍게 보기이런식으로 흘러가는구나 정도만 알면됨

  

  HTTP 1.1가 요청을 받아서 요청 정보를 request에 담고, response를 만들어서 준다. 그 시점이 여기다.

  

  요청이 오면 쓰레드 풀에서(쓰레드들을 미리 만들어 놓는다. Why? 요청 왔을 때 만들면 느리니까) 한가한 쓰레드가 요청을 받아서 처리한다. 그리고 프로토콜에 따라서 연결한다.(HTTP 프로토콜이면 1.1이 받고..)

  Dispatcher Servlet이 Controller에 메서드를 호출한다.

Tomcat의 설정 파일 - server.xml, web.xml

💡

톰캣설치경로/conf/server.xml : Tomcat 서버 설정 파일

톰캣설치경로/conf/web.xml : Tomcat의 모든 web app의 공통 설정

웹앱이름/WEB-INF/web.xml : web app의 개별 설정

※ web app = 웹 애플리케이션

• server.xml에서 보는 톰캣 내부 구조

  unpackWARs=”true” 톰캣 실행 시 war 파일이 있으면 자동으로 압축을 풀어라

  

  

  이 두가지가 원래 web.xml에서 설정했어야 했는데 불편해서 애너테이션으로 바뀌었다.

  

  

HTTP 요청과 응답

1. 프로토콜(protocol)이란?

💡

서로 간의 통신을 위한 약속, 규칙
주고 받을 Data에 대한 형식을 정의한 것

Data를 어떻게 주고 받을지 미리 약속하지 않으면 Data를 받아도 이게 어떤 내용인지 해석할 수 없다. 그렇기 때문에 어떤 형식으로 Data를 주고 받을지 미리 약속해야 한다.

서로의 소통을 위해서 미리 정해놓은 규칙 = 프로토콜

⇒ 그냥 쉽게 프로토콜은 약속, 규칙이라고 외우자!

<이해를 돕기위한 실생활에서의 예>

편지의 보내는 사람 위치, 받는 사람 위치, 우표 위치 이런 것들이 바로 프로토콜이다.

편지를 보내는 사람, 받는 사람, 배달 하는 사람끼리 이런 프로토콜(사회적인 합의)이 있기 때문에 우리가 별다른 설명 없이 이해하고 사용할 수 있는 것이다.

2. HTTP(Hyper Text Transfer Protocol)란?

텍스트 전송 프로토콜

⇒ 텍스트를 전송하기 위한 프로토콜(약속, 규칙)

※ Hyper Text = HTML

<특징>

• 단순하고 읽기 쉽다. - 텍스트 기반의 프로토콜

• 상태를 유지하지 않는다.(stateless) - Client 정보를 저장X

  같은 Client가 요청을 두 번 보냈을 때 Server는 이 두 요청이 같은 Client가 보낸 것인지 구별 못한다.

  Why? 클라이언트 정보를 저장하지 않기 때문에

  → 이런 단점을 보완하기 위해서 사용하는 것이 쿠키와 세션이다.(클라이언트 구별 가능하게됨)

  

• 확장 가능하다. - 커스텀 헤더(header) 추가 가능

  

3. HTTP 메시지

편지하고 비슷하다. 둘 다 텍스트이다.

헤더 = 본문에 대한 설명 | 편지에 대한 설명.

바디 = 실제 전달할 내용.

HTTP 프로토콜은 서로에게 요청 편지를 보내고, 상대방은 요청에 대한 응답 편지를 보낸다고 생각하면 된다.

우리는 URL만 입력했지만 브라우저가 아래 그림처럼 HTTP 요청 메시지를 만들어서 서버에게 전송해준다.

응답 내용이 브라우저에 Hello라고 해석되어 나오는 것이다.

HTTP 메시지 - 응답 메시지

HTTP 응답 메시지 foramt에 맞춰서 줘야 Client가 내용을 이해할 수 있다.

상태 라인 = 요청이 어떻게 처리되었는지 알려준다.

상태 코드 옆에는 설명

아래의 기본적인 상태코드는 외워야 한다.

HTTP 상태코드	의미	상세 설명
1xx	Informational	HTTP/1.1 추가 정보 교환
2xx	Success	성공
3xx	Redirect	다른 URL 요청
4xx	Client Error	클라이언트 잘못
5xx	Server Error	서버 잘못

400번대 - Client Error

클라이언트가 요청을 잘못한 것이다. 서버는 잘못한 것 X

내가 요청한 리소스를 찾을 수 없음

500번대 - Server Error

클라이언트 잘못X. 서버 잘못.

나는 요청을 제대로 했는데 요청을 처리하다가 프로그램에 문제가 있어서 에러가 발생한 것이다.

HTTP 메시지 - 요청 메시지

종류(대표적인 거 두개만)

1. GET - read

   단순히 서버 리소스를 가져온다. 즉 읽기.

   리소스 URL만 적어주면 되어서 바디가 필요없고 헤더만 존재한다.

   Data를 보낼 게 있으면 쿼리 스트링으로 보낼 수 있다.

2. POST - write or 서버에 데이터 제공

   write, 글쓰기, 회원가입, 파일 첨부, 서버에 Data 제공 이런 용도로 만들어진 것이다.

   POST같은 경우는 body가 있어서 GET에서 썼던 쿼리 스트링이 body에 들어간다.

   → 서버에 전송할 Data를 body에 담는다.

HTTP 메서드 - GET, POST

	GET	POST
설계 목적	서버의 리소스를 가져오기 위해 설계	서버에 데이터를 올리기 위해 설계
데이터 전송	Query String을 통해 데이터를 전달(소용량)	전송 데이터 크기의 제한이 없음(대용량)
보안	URL에 데이터 노출되므로 보안에 취약	데이터를 요청 메시지의 body에 담아 전송 → 보안에 유리
데이터 공유	데이터 공유에 유리	데이터 공유에 불리

그냥 단순히 POST 방식이라고 해서 보안에 유리한 게 아니라

HTTP + TLS(암호화 프로토콜) ⇒ HTTPS여야 보안에 유리한 것이다. TLS 없이 POST로 보냈다고 보안에 유리하지는 않다.

SSL(old) → TLS(new)

보안 프로토콜

• 개발자 도구로 요청 헤더 살펴보기

  개발자도구 켠 상태에서 새로고침하고 네트워크 → getYoil 누르면 요청에 대한 헤더를 볼 수 있다.

  

  뷰 소스 누르면 원래 요청이 어떻게 갔는지 볼 수 있다.

  General 헤더는 요청 헤더, 응답 헤더를 제외한 일반적인 헤더이다.(요청과 응답의 공통적인 헤더)

  

  Response 탭을 누르면 응답을 볼 수 있다.

  

• 포스트맨으로 요청 헤더 살펴보기

  

  

  

텍스트 파일 VS 바이너리 파일

💡

바이너리 파일 : 문자 + 숫자가 저장되어 있는 파일

텍스트 파일 : 문자만 저장되어있는 파일

아래는 image.jpg라는 이미지 파일을 메모장으로 연 것이다.

메모장으로 열었을 때 읽을 수 있으면 텍스트 파일, 읽을 수 없으면 바이너리 파일이다.

바이너리 파일 : 데이터를 있는 그대로 읽고 쓴다.

텍스트 파일 : 숫자를 문자로 변환 후 쓴다.

파일 종류	쓰기	읽기
바이너리	문자 → 문자 숫자 → 숫자	문자 → 문자 숫자 → 숫자
텍스트	문자 → 문자 숫자 → 문자	문자 → 문자 문자 → 숫자

8. MIME(Multipurpost Internet Mail Extensions)

HTTP는 텍스트 기반이다.(HTTP = Hyper Text Transfer Protocol) 그럼 텍스트밖에 전송을 못할까? 아니다. 우리는 이미 브라우저에서 이미지, 동영상(바이너리 파일)을 다 보고 있다.

텍스트 기반 프로토콜에서 바이너리를 어떻게 전송할까? MIME(전송할 데이터의 타입)을 적어주면 된다.

ex ) response.setContentType("text/html");

타입	설명	MIME타입 예시(타입/서브타입)
text	텍스트를 포함하는 모든 문서	text/plain, text/html, text/css, text/javascript
image	모든 종류의 이미지	image/bmp, image/webp
audio	모든 종류의 오디오 파일	audio/midi, audio/mpeg, audio/webm, audio/ogg, audio/wav
video	모든 종류의 비디오 파일	video/webm, video/ogg
application	모든 종류의 이진 데이터	application/octetstream, application/pkcs12, application/vnd.mspowerpoint, application/xhtml+xml, application/xml, application/pdf

• 실습 : 포스트맨을 통해 텍스트가 아닌 이미지 데이터 전송하기

  

  

• 예제1 : RequestHeader(실제로 내가 요청한게 어떤 내용, 어떤 헤더로 가는지 확인)

  package com.fastcampus.ch2;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  import javax.servlet.http.HttpServletRequest;
  import java.util.Enumeration;
  
  @Controller // 1. 원격 호출 가능한 프로그램으로 등록
  public class RequestHeader {
      @RequestMapping("/requestHeader") // 2. URL과 메서드 연결
      public void main(HttpServletRequest request) {
          Enumeration<String> e = request.getHeaderNames();
  
          while (e.hasMoreElements()) {
              String name = e.nextElement(); // 요청 헤더의 이름은 대소문자 구분하지 않는다.
              System.out.println(name + ":" + request.getHeader(name));
          }
      }
  }

• 예제2 : 헤더뿐 아니라 메시지 전체를 보여주는 예제

  

  package com.fastcampus.ch2;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Enumeration;
  import javax.servlet.http.HttpServletRequest;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  @Controller
  public class RequestMessage {
      @RequestMapping("/requestMessage")
      public void main(HttpServletRequest request) throws Exception {
  
          // 1. request line
          String requestLine = request.getMethod();       // GET 또는 POST
          requestLine += " " + request.getRequestURI();   // /ch2/requestMessage 이건 자주 사용하니 잘 알아둘 것
  
          String queryString = request.getQueryString();  // year=2021&month=10&day=1
          requestLine += queryString == null ? "" : "?" + queryString;
          requestLine += " " + request.getProtocol();     // HTTP/1.1
          System.out.println(requestLine);
  
  
          // 2. request headers
          Enumeration<String> e = request.getHeaderNames();
  
          while (e.hasMoreElements()) {
              String name = e.nextElement();
              System.out.println(name + ":" + request.getHeader(name));
          }
  
          // 3. request body - POST일 때만 해당, GET은 body가 없음(CONTENT_LENGTH=0)
          final int CONTENT_LENGTH = request.getContentLength();
  //		System.out.println("content length="+CONTENT_LENGTH);
  
          if (CONTENT_LENGTH > 0) {
              byte[] content = new byte[CONTENT_LENGTH];
  
              InputStream in = request.getInputStream();
              in.read(content, 0, CONTENT_LENGTH);
  
              System.out.println(); // empty line
              System.out.println(new String(content, "utf-8")); // year=2021&month=10&day=1
          }  // if
      } // main
  }

9. Base64

: 바이너리 데이터를 텍스트 데이터로 변환할 때 사용한다.

2진법 = base2 = 0, 1

10진법 = base10 = 0~9

16진법 = base16 = 0~9 ABCDEF

64진법 = A~Z, a-z, 0~9, +, / ⇒ 모두 64개(6 bit)의 문자로 구성

<바이너리 데이터를 텍스트 기반인 HTTP 프로토콜로 보내는 방법>

1. MIME으로 바이너리 그대로 보내기

2. Base64로 바이너리를 텍스트로 변환해서 보낸다.

   단점 : Data의 사이즈가 커진다.

2. 공통 코드의 분리 - 입력의 분리

3. 출력(view)의 분리 - 변하는 것과 변하지 않는 것의 분리

4. MVC 패턴

스프링 MVC가 이런 구조로 되어있다.

DispatcherServlet이 앞에서 입력처리, Model(결과를 저장할 객체)을 만든 다음에 그걸 Controller에게 넘겨준다. Controller가 그걸 받고 결과를 저장해서 주면 그걸 View한테 전달해준다. 뷰에서는 작업한 결과를 가지고 최종 응답을 만들어서 Client에게 보낸다.

사용자가 선택한 뷰로 보여준다.

<MVC>

1. 입력받을 값들을 매개변수로 선언.

2. Model을 선언해서 작업을 처리

3. Model에 작업 결과를 저장

4. 이 작업 결과를 보여줄 View 반환

5. DispatcherServlet이 작성 결과가 저장되어있는 Model을 View에다 전달.

6. 그래서 View는 Data가 담겨있는 Model 객체에서 값을 읽을 수 있는 것이다.

+) 실습

package com.fastcampus.ch2;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Calendar;

// 년월일을 입력하면 해당 날짜가 어떤 요일인지 알려주는 프로그램
// 1. 원격 호출이 가능한 프로그램으로 변경
@Controller
public class YoilTeller {
//    public static void main(String[] args) {
    @RequestMapping("/getYoil") // 2. URL과 메서드 연결
    public void main(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 1. 입력
        String year = request.getParameter("year");
        String month = request.getParameter("month");
        String day = request.getParameter("day");

        int yyyy = Integer.valueOf(year);
        int mm = Integer.parseInt(month);
        int dd = Integer.parseInt(day);

       // 2. 작업
        Calendar cal = Calendar.getInstance();
        cal.set(yyyy, mm - 1, dd);

        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); // 1 : 일요일, 2 : 월요일
        char yoil = " 일월화수목금토".charAt(dayOfWeek);

        // 3. 출력
        System.out.printf("%d년 %d월 %d일은 ", yyyy, mm, dd);
        System.out.println(yoil + "요일입니다.");

        // 이렇게 하는 이유는 브라우저는 내가 보내는 내용이 텍스트인지 바이너리인지 모르기 때문이다.
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8"); // 이게 없으면 한글 깨진다. 우리가 보내는 텍스트 인코딩이 무엇인지 알려줘야 브라우저가 해석 가능

        PrintWriter out = response.getWriter(); // response 객체에서 브라우저로의 출력 스트림을 얻는다.
        out.printf("%d년 %d월 %d일은 ", yyyy, mm, dd);
        out.println(yoil + "요일입니다.");
    }
}

package com.fastcampus.ch2;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.Calendar;

// 년월일을 입력하면 해당 날짜가 어떤 요일인지 알려주는 프로그램
// 1. 원격 호출이 가능한 프로그램으로 변경
@Controller
public class YoilTellerMVC { // http://l
//    public static void main(String[] args) {
    @RequestMapping("/getYoilMVC") // 2. URL과 메서드 연결
//    public void main(HttpServletRequest request, HttpServletResponse response) throws Exception {
    public String main(int year, int month, int day, Model model) throws Exception {
        // 1. 유효성 검사
        if (!isValid(year, month, day))
            return "yoilError";

        // 2. 요일 계산
        char yoil = getYoil(year, month, day);

        // 3. 계산한 결과를 model에 저장
        model.addAttribute("year", year);
        model.addAttribute("month", month);
        model.addAttribute("day", day);
        model.addAttribute("yoil", yoil);

        return "yoil";
    }

    private boolean isValid(int year, int month, int day) {
        return true;
    }

    private char getYoil(int year, int month, int day) {

        Calendar cal = Calendar.getInstance();
        cal.set(year, month - 1, day);

        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); // 1 : 일요일, 2 : 월요일
        return " 일월화수목금토".charAt(dayOfWeek);
    }
}

servlet-context.xml(웹 관련된 설정 파일) +) root-context.xml : 웹 관련되지 않은 설정파일

prefix = 접두사, view의 경로를 지정하는 곳

suffix = 접미사

이 설정 덕분에 View의 이름만 반환해주어도 앞에 경로가 붙고, 뒤에 확장자가 붙는 것이다.

이렇게 공통 부분을 분리해놓으면 나중에 변경사항(ex. view 경로 변경)이 생겼을 때 쉽게 변경이 가능하다.

5. ModelAndView

6. 컨트롤러 메서드의 반환타입

<컨트롤러 메서드의 반환타입>

1. 뷰의 이름 반환 O ← 이거를 제일 많이 쓴다.

2. 뷰의 이름 반환 X

   뷰의 이름을 반환해주지 않으면 매핑된 url에 의해서 View의 이름이 결정된다.(매핑된 주소.jsp로 해석된다.)

   이렇게는 잘 안 쓰지만 가능하다는 것만 알아주자.

   • 예제 코드

     @RequestMapping("/getYoilMVC") // 2. URL과 메서드 연결
     //    public void main(HttpServletRequest request, HttpServletResponse response) throws Exception {
     public void main(int year, int month, int day, Model model) throws Exception {
         // 1. 유효성 검사
     //        if (!isValid(year, month, day))
     //            return "yoilError";
     
         // 2. 요일 계산
         char yoil = getYoil(year, month, day);
     
         // 3. 계산한 결과를 model에 저장
         model.addAttribute("year", year);
         model.addAttribute("month", month);
         model.addAttribute("day", day);
         model.addAttribute("yoil", yoil);
     
     //        return "yoil";
     }

3. ModelAndView

   자주 사용하는 편은 아님. 있다는 것만 알아두자

   • 코드

     @RequestMapping("/getYoilMVC") // 2. URL과 메서드 연결
     //    public void main(HttpServletRequest request, HttpServletResponse response) throws Exception {
         public ModelAndView main(int year, int month, int day) throws Exception {
             ModelAndView mv = new ModelAndView();
     
     
             // 1. 유효성 검사
     //        if (!isValid(year, month, day))
     //            return "yoilError";
     
             // 2. 요일 계산
             char yoil = getYoil(year, month, day);
     
             // 3. 계산한 결과를 model에 저장
             mv.addObject("year", year);
             mv.addObject("month", month);
             mv.addObject("day", day);
             mv.addObject("yoil", yoil);
     
             // 4.  결과를 보여줄 view를 지정
             mv.setViewName("yoil");
     
             return mv;
     //        return "yoil";
         }

+) MVC 패턴의 원리

매개변수 이름을 얻는 방법

1. 리플렉션 API

   -parameters 옵션을 넣고 컴파일을 해야 한다. jdk1.8부터 가능

   javac -parameters 명령어에서 -parameters 옵션이 빠지면 클래스파일에 매개변수이름을 저장하지않는다

2. Class file

• MethodInfo.java

  package com.fastcampus.ch2;
  
  import java.lang.reflect.Method;
  import java.lang.reflect.Parameter;
  import java.util.StringJoiner;
  
  public class MethodInfo {
      public static void main(String[] args) throws Exception {
          // 1. YoilTeller 클래스의 객체를 생성
          Class clazz = Class.forName("com.fastcampus.ch2.YoilTellerMVC");
          Object obj = clazz.newInstance();
  
          // 2. 모든 메서드 정보를 가져와서 배열에 저장
          Method[] methodArr = clazz.getDeclaredMethods();
  
          for (Method m : methodArr) {
              String name = m.getName(); // 메서드의 이름
              Parameter[] paramArr = m.getParameters(); // 매개변수 목록
  //			Class[] paramTypeArr = m.getParameterTypes();
              Class returnType = m.getReturnType(); // 반환 타입
  
              StringJoiner paramList = new StringJoiner(", ", "(", ")");
  
              for (Parameter param : paramArr) {
                  String paramName = param.getName();
                  Class paramType = param.getType();
  
                  paramList.add(paramType.getName() + " " + paramName);
              }
  
              System.out.printf("%s %s%s%n", returnType.getName(), name, paramList);
          }
      } // main
  }
  
  /* [실행결과]
  java.lang.String main(java.lang.String year, java.lang.String month, java.lang.String day, org.springframework.ui.Model model)
  boolean isValid(int year, int month, int day)
  */

---

화면에 보여주는 부분 JSP의 원리, 이해

JSP도 아래와 같이 되어있는 것이다. view를 여러개 만들어놓고 view이름을 다르게 반환하면 view에 맞게 값들을 채워서 결과를 보여준다.

• MethodCall.java

  package com.fastcampus.ch2;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Scanner;
  import java.util.Set;
  
  class ModelController {
      public String main(HashMap map) {
          map.put("id", "asdf");
          map.put("pwd", "1111");
  
          return "txtView1";
      }
  }
  public class MethodCall {
      public static void main(String[] args) throws Exception {
          HashMap map = new HashMap();
          System.out.println("before:" + map);
  
          // 컨트롤러를 직접 생성하고 메서드를 호출.
          ModelController mc = new ModelController();
          String viewName = mc.main(map);
  
          System.out.println("after :" + map);
  
          // 작업 결과가 담긴 data, 뷰 이름
          render(map, viewName);
      }
  
      static void render(HashMap map, String viewName) throws IOException {
          String result = "";
  
          // 1. 뷰의 내용을 한줄씩 읽어서 하나의 문자열로 만든다.
          Scanner sc = new Scanner(new File(viewName + ".txt"));
  
          while (sc.hasNextLine())
              result += sc.nextLine() + System.lineSeparator();
  
          // 2. map에 담긴 key를 하나씩 읽어서 template의 ${key}를 value바꾼다.
          Iterator it = map.keySet().iterator();
  
          while (it.hasNext()) {
              String key = (String) it.next();
  
              // 3. replace()로 key를 value 치환한다.
              result = result.replace("${" + key + "}", (String) map.get(key));
          }
  
          // 4.렌더링 결과를 출력한다.
          System.out.println(result);
      }
  }
  
  
  
  //[txtView1.txt]
  //        id=${id}, pwd=${pwd}
  //
  //        [txtView2.txt]
  //        id:${id}
  //        pwd:${pwd}
  //
  //
  //
  //        [실행결과]
  //        before:{}
  //        after :{id=asdf, pwd=1111}
  //        [txtView2.txt]
  //        id:asdf
  //        pwd:1111

• MethodCall2.java

  package com.fastcampus.ch2;
  
  import java.io.File;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Scanner;
  
  import org.springframework.ui.Model;
  import org.springframework.validation.support.BindingAwareModelMap;
  
  public class MethodCall2 {
      public static void main(String[] args) throws Exception {
  
          // 1. YoilTellerMVC의 객체를 생성
          Class clazz = Class.forName("com.fastcampus.ch2.YoilTellerMVC");
          Object obj = clazz.newInstance();
  
          // 2. main 메서드의 정보를 가져온다.
          Method main = clazz.getDeclaredMethod("main", int.class, int.class, int.class, Model.class);
  
          // 3. Model을 생성
          Model model = new BindingAwareModelMap(); // Model은 인터페이스라 객체를 생성할 수 없다. Model의 구현체가 BindingAwareModelMap인 것이다.
          System.out.println("[before] model=" + model);
  
          // 4. main 메서드를 호출
          // String viewName = obj.main(2021, 10, 1, model); // 리플렉션 API 사용 X
          String viewName = (String) main.invoke(obj, new Object[]{2021, 10, 1, model}); // 리플렉션 API를 이용한 호출
          System.out.println("viewName=" + viewName);
  
          // Model의 내용을 출력
          System.out.println("[after] model=" + model);
  
          // 텍스트 파일을 이용한 rendering
          render(model, viewName);
      } // main
  
      static void render(Model model, String viewName) throws IOException {
          String result = "";
  
          // 1. 뷰의 내용을 한줄씩 읽어서 하나의 문자열로 만든다.
          Scanner sc = new Scanner(new File("src/main/webapp/WEB-INF/views/" + viewName + ".jsp"), "utf-8");
  
          while (sc.hasNextLine())
              result += sc.nextLine() + System.lineSeparator();
  
              // 2. model을 map으로 변환
              Map map = model.asMap();
  
              // 3.key를 하나씩 읽어서 template의 ${key}를 value바꾼다.
              Iterator it = map.keySet().iterator();
  
              while (it.hasNext()) {
                  String key = (String) it.next();
  
                  // 4. replace()로 key를 value 치환한다.
                  result = result.replace("${" + key + "}", "" + map.get(key));
          }
  
          // 5.렌더링 결과를 출력한다.
          System.out.println(result);
      }
  }
  
  /* [실행결과]
  [before] model={}
  viewName=yoil
  [after] model={year=2021, month=10, day=1, yoil=금}
  <%@ page contentType="text/html;charset=utf-8" %>
  <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  <%@ page session="false" %>
  <html>
  <head>
  	<title>YoilTellerMVC</title>
  </head>
  <body>
  <h1>2021년 10월 1일은 금요일입니다.</h1>
  </body>
  </html>
  
  */

• MethodCall3.java

  package com.fastcampus.ch2;
  
  import java.io.File;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Parameter;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Scanner;
  
  import org.springframework.ui.Model;
  import org.springframework.validation.support.BindingAwareModelMap;
  
  public class MethodCall3 {
      public static void main(String[] args) throws Exception {
          // 1. 요청 시 넘어온 값 - request.getParameterMap();
          Map map = new HashMap();
          map.put("arg0", "2021");
          map.put("arg1", "10");
          map.put("arg2", "1");
  
          Model model = null;
          Class clazz = Class.forName("com.fastcampus.ch2.YoilTellerMVC");
          Object obj = clazz.newInstance();
  
          // YoilTellerMVC.main(int year, int month, int day, Model model)
          Method main = clazz.getDeclaredMethod("main", int.class, int.class, int.class, Model.class);
  
          // 핵심 s
          Parameter[] paramArr = main.getParameters(); // main 메서드의 매개변수 목록을 가져온다.
          Object[] argArr = new Object[main.getParameterCount()];
  
          for (int i = 0; i < paramArr.length; i++) {
              String paramName = paramArr[i].getName();
              Class paramType = paramArr[i].getType();
              Object value = map.get(paramName); // map에서 못찾으면 value는 null
  
              // paramType중에 Model이 있으면, 생성 & 저장
              if (paramType == Model.class) {
                  argArr[i] = model = new BindingAwareModelMap();
              } else if (value != null) {  // map에 paramName이 있으면,
                  // value와 parameter의 타입을 비교해서, 다르면 변환해서 저장
                  argArr[i] = convertTo(value, paramType);
              }
          }
          System.out.println("paramArr=" + Arrays.toString(paramArr));
          System.out.println("argArr=" + Arrays.toString(argArr));
          // 핵심 e
  
          // Controller의 main()을 호출 - YoilTellerMVC.main(int year, int month, int day, Model model)
          String viewName = (String) main.invoke(obj, argArr);
          System.out.println("viewName=" + viewName);
  
          // Model의 내용을 출력
          System.out.println("[after] model=" + model);
  
          // 텍스트 파일을 이용한 rendering
          render(model, viewName);
      } // main
  
      private static Object convertTo(Object value, Class type) {
          if (type == null || value == null || type.isInstance(value)) // 타입이 같으면 그대로 반환
              return value;
  
          // 타입이 다르면, 변환해서 반환
          if (String.class.isInstance(value) && type == int.class) { // String -> int
              return Integer.valueOf((String) value);
          } else if (String.class.isInstance(value) && type == double.class) { // String -> double
              return Double.valueOf((String) value);
          }
  
          return value;
      }
  
      private static void render(Model model, String viewName) throws IOException {
          String result = "";
  
          // 1. 뷰의 내용을 한줄씩 읽어서 하나의 문자열로 만든다.
          Scanner sc = new Scanner(new File("src/main/webapp/WEB-INF/views/" + viewName + ".jsp"), "utf-8");
  
          while (sc.hasNextLine())
              result += sc.nextLine() + System.lineSeparator();
  
          // 2. model을 map으로 변환
          Map map = model.asMap();
  
          // 3.key를 하나씩 읽어서 template의 ${key}를 value바꾼다.
          Iterator it = map.keySet().iterator();
  
          while (it.hasNext()) {
              String key = (String) it.next();
  
              // 4. replace()로 key를 value 치환한다.
              result = result.replace("${" + key + "}", "" + map.get(key));
          }
  
          // 5.렌더링 결과를 출력한다.
          System.out.println(result);
      }
  }
  
  /* [실행결과]
  paramArr=[int year, int month, int day, org.springframework.ui.Model model]
  argArr=[2021, 10, 1, {}]
  viewName=yoil
  [after] model={year=2021, month=10, day=1, yoil=금}
  <%@ page contentType="text/html;charset=utf-8" %>
  <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  <%@ page session="false" %>
  <html>
  <head>
  	<title>YoilTellerMVC</title>
  </head>
  <body>
  <h1>2021년 10월 1일은 금요일입니다.</h1>
  </body>
  </html>

• MyDispatcherServlet.java

  package com.fastcampus.ch2;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.lang.reflect.Array;
  import java.lang.reflect.Method;
  import java.lang.reflect.Parameter;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Scanner;
  
  import javax.servlet.annotation.WebServlet;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.springframework.ui.Model;
  import org.springframework.validation.support.BindingAwareModelMap;
  
  // @Controller + @RequestMapping
  @WebServlet("/myDispatcherServlet")  // http://localhost/ch2/myDispatcherServlet?year=2021&month=10&day=1
  public class MyDispatcherServlet extends HttpServlet {
      @Override
      public void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
          Map map = request.getParameterMap(); // year, month, day를 map으로 가져오게된다.
          Model model = null;
          String viewName = "";
  
          try {
              Class clazz = Class.forName("com.fastcampus.ch2.YoilTellerMVC");
              Object obj = clazz.newInstance();
  
              // 1. main메서드의 정보를 얻는다.
              Method main = clazz.getDeclaredMethod("main", int.class, int.class, int.class, Model.class);
  
              // 2. main메서드의 매개변수 목록(paramArr)을 읽어서 메서드 호출에 사용할 인자 목록(argArr)을 만든다.
              Parameter[] paramArr = main.getParameters();
              Object[] argArr = new Object[main.getParameterCount()];
  
              for (int i = 0; i < paramArr.length; i++) {
                  String paramName = paramArr[i].getName();
                  Class paramType = paramArr[i].getType();
                  Object value = map.get(paramName);
  
                  // paramType중에 Model이 있으면, 생성 & 저장
                  if (paramType == Model.class) {
                      argArr[i] = model = new BindingAwareModelMap();
                  } else if (paramType == HttpServletRequest.class) {
                      argArr[i] = request;
                  } else if (paramType == HttpServletResponse.class) {
                      argArr[i] = response;
                  } else if (value != null) {  // map에 paramName이 있으면,
                      // value와 parameter의 타입을 비교해서, 다르면 변환해서 저장
                      String strValue = ((String[]) value)[0];    // getParameterMap()에서 꺼낸 value는 String배열이므로 변환 필요
                      argArr[i] = convertTo(strValue, paramType);
                  }
              }
  
              // 3. Controller의 main()을 호출 - YoilTellerMVC.main(int year, int month, int day, Model model)
              viewName = (String) main.invoke(obj, argArr);
          } catch (Exception e) {
              e.printStackTrace();
          }
  
          // 4. 텍스트 파일을 이용한 rendering
          render(model, viewName, response);
      } // main
  
      private Object convertTo(Object value, Class type) {
          if (type == null || value == null || type.isInstance(value)) // 타입이 같으면 그대로 반환
              return value;
  
          // 타입이 다르면, 변환해서 반환
          if (String.class.isInstance(value) && type == int.class) { // String -> int
              return Integer.valueOf((String) value);
          } else if (String.class.isInstance(value) && type == double.class) { // String -> double
              return Double.valueOf((String) value);
          }
  
          return value;
      }
  
      private String getResolvedViewName(String viewName) {
          return getServletContext().getRealPath("/WEB-INF/views") + "/" + viewName + ".jsp";
      }
  
      private void render(Model model, String viewName, HttpServletResponse response) throws IOException {
          String result = "";
  
          response.setContentType("text/html");
          response.setCharacterEncoding("utf-8");
          PrintWriter out = response.getWriter();
  
          // 1. 뷰의 내용을 한줄씩 읽어서 하나의 문자열로 만든다.
          Scanner sc = new Scanner(new File(getResolvedViewName(viewName)), "utf-8");
  
          while (sc.hasNextLine())
              result += sc.nextLine() + System.lineSeparator();
  
          // 2. model을 map으로 변환
          Map map = model.asMap();
  
          // 3.key를 하나씩 읽어서 template의 ${key}를 value바꾼다.
          Iterator it = map.keySet().iterator();
  
          while (it.hasNext()) {
              String key = (String) it.next();
  
              // 4. replace()로 key를 value 치환한다.
              result = result.replace("${" + key + "}", map.get(key) + "");
          }
  
          // 5.렌더링 결과를 출력한다.
          out.println(result);
      }
  }

원리에 대한 예제. 계속 바꿔가면서 발전시켜나가면 좋은 공부가 될 것.

13~16. 서블릿과 JSP

1. 서블릿과 컨트롤러의 비교

서블릿 → 스프링

1. 상속 제거됨

2. 매개변수 필요한 것만 적으면됨

3. 애너테이션 나눠서 처리

   ㄴ 기존에는 url 매핑을 클래스 단위로 했었음

2. 서블릿의 생명주기

• HelloServlet.java

  package com.fastcampus.ch2;
  
  import javax.servlet.ServletException;
  import javax.servlet.annotation.WebServlet;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  
  @WebServlet("/hello")
  public class HelloServlet extends HttpServlet {
      @Override
      public void init() throws ServletException {
          // 서블릿이 초기화될 때 자동 호출되는 메서드
          // 1. 서블릿의 초기화 작업 담당
          System.out.println("[HelloServlet] init() is called.");
  //        super.init();
      }
  
      @Override
      protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          // 1. 입력
          // 2. 처리
          // 3. 출력
          System.out.println("[HelloServlet] service() is called.");
          super.service(req, resp);
      }
  
      @Override
      public void destroy() {
          // 3. 뒷정리 - 서블릿이 메모리에서 제거될 때 서블릿 컨테이너에 의해서 자동 호출
          System.out.println("[HelloServlet] destroy() is called.");
          super.destroy();
      }
  }

요청이 오면 서블릿 인스턴스가 존재하는지 Servlet Context에서 확인한다. 인스턴스가 존재한다면 service()를 호출하고 없다면 인스턴스를 생성하는데, 서블릿은 싱글톤으로 되어있다. 1개의 인스턴스만 만들어서 재사용한다.

WHY? 사람마다 처리되어야 할 작업이 똑같이 때문에 프로그램이 여러개 있을 필요가 없다. 그래서 싱글톤으로 1개의 인스턴스만 만들어서 재사용한다.

+) Spring도 마찬가지.

❓서블릿은 Singleton인데 여러 사용자가 동시에 같은 요청을 동시에 보내도 가능한 이유?

서블릿이 멀티스레드 환경에서 동작하도록 설계되어 있기 때문이다.

그리고 서블릿 내에 iv가 없기 때문에 싱글톤이어도 괜찮다. 전부 다 lv이기 때문

iv여도 괜찮은 경우는

1. 상수

2. 다른 객체를 멤버로 가지고 있는데 이 객체에 iv가 존재하지 않는 경우

int num; 과 같은 iv가 필요할 경우에는 싱글톤으로는 불가능하다.

@WebServlet("/loginTest1")
public class LoginServlet extends HttpServlet {
    LoginFilter loginFilter; // iv, loginFilter는 iv가 없음.
    final int MAX_VALUE = 10; // iv지만 상수라서 OK

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String id = request.getParameter("id");
        String pwd = request.getParameter("pwd");
    }
}

그래서 스프링에서는 2가지를 제공한다.

1. Singleton : default, 1개

2. Prototype : 요청할 때마다 객체 생성. iv 사용 가능

Prototype으로 사용할 경우 서버 부담이 크기 때문에 웬만하면 iv는 사용하지 않는 게 좋다.(위에서 설명한 경우는 제외(1. 상수, 2. 포함 관계인데 그 객체에 iv가 없는 경우)

---

Servlet Context : 서블릿 컨텍스트에 포함된 서블릿들이 여기 다 등록되어있다.

4. JSP와 서블릿의 비교

5. JSP의 호출 과정

6. JSP와 서블릿으로 변환된 JSP 비교

7. JSP의 기본 객체

기본 객체	타입	설명
request	javax.servlet.http.HttpServletRequest	요청 정보가 담겨있는 객체
response	javax.servlet.http.HttpServletResponse	요청에 응답을 작성할 때 사용
session	javax.servlet.http.HttpSession	HTTP session을 구현한 객체. 세션 정보 저장에 사용
application	javax.servlet.ServletContext	Web Application 전체에서 공유하는 객체
config	javax.servlet.ServletConfig	JSP 페이지에 대한 설정 정보가 담긴 객체
page	java.lang.Object	JSP 페이지 객체 자신
pageContext	javax.servlet.jsp.PageContext	JSP페이지의 context정보를 제공
out	javax.servlet.jsp.JspWriter	응답에 포함될 내용을 출력할 때 사용
exception	java.lang.Throwable	예외가 발생했을 때 생성되는 예외 객체

8. 유효 범위(scope)와 속성(attribute)

<4개 저장소>

1. 접근 범위

2. 생존 기간

1. pageContext

2. application

3. session

4. request

• requestInfo.java

  package com.fastcampus.Test;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  import javax.servlet.http.HttpServletRequest;
  
  @Controller
  public class RequestInfo {
      @RequestMapping("/requestInfo")
      //    public static void main(String[] args) {
      public void main(HttpServletRequest request) {
          System.out.println("request.getCharacterEncoding()="+request.getCharacterEncoding()); // 요청 내용의 인코딩
          System.out.println("request.getContentLength()="+request.getContentLength());  // 요청 내용의 길이. 알수 없을 때는 -1
          System.out.println("request.getContentType()="+request.getContentType()); // 요청 내용의 타입. 알 수 없을 때는 null
  
          System.out.println("request.getMethod()="+request.getMethod());      // 요청 방법
          System.out.println("request.getProtocol()="+request.getProtocol());  // 프로토콜의 종류와 버젼 HTTP/1.1
          System.out.println("request.getScheme()="+request.getScheme());      // 프로토콜
  
          System.out.println("request.getServerName()="+request.getServerName()); // 서버 이름 또는 ip주소
          System.out.println("request.getServerPort()="+request.getServerPort()); // 서버 포트
          System.out.println("request.getRequestURL()="+request.getRequestURL()); // 요청 URL
          System.out.println("request.getRequestURI()="+request.getRequestURI()); // 요청 URI
  
          System.out.println("request.getContextPath()="+request.getContextPath()); // context path
          System.out.println("request.getServletPath()="+request.getServletPath()); // servlet path
          System.out.println("request.getQueryString()="+request.getQueryString()); // 쿼리 스트링
  
          System.out.println("request.getLocalName()="+request.getLocalName()); // 로컬 이름
          System.out.println("request.getLocalPort()="+request.getLocalPort()); // 로컬 포트
  
          System.out.println("request.getRemoteAddr()="+request.getRemoteAddr()); // 원격 ip주소
          System.out.println("request.getRemoteHost()="+request.getRemoteHost()); // 원격 호스트 또는 ip주소
          System.out.println("request.getRemotePort()="+request.getRemotePort()); // 원격 포트
      }
  }
  //
  //[실행결과] http://localhost:8080/ch2/requestInfo?year=2021&month=10&day=1
  //request.getCharacterEncoding()=UTF-8
  //request.getContentLength()=-1
  //request.getContentType()=null
  //request.getMethod()=GET
  //request.getProtocol()=HTTP/1.1
  //request.getScheme()=http
  //request.getServerName()=localhost
  //request.getServerPort()=8080
  //request.getRequestURI()=http://localhost:8080/ch2/requestInfo
  //request.getRequestURI()=/ch2/requestInfo
  //request.getContextPath()=/ch2
  //request.getServletPath()=/requestInfo
  //request.getQueryString()=year=2021&month=10&day=1
  //request.getLocalName()=localhost
  //request.getLocalPort()=8080
  //request.getRemoteAddr()=0:0:0:0:0:0:0:1   <--- AWS에 배포(deploy)한 다음에 실행하면, 실제 ip주소를 확인할 수 있음.
  //request.getRemoteHost()=0:0:0:0:0:0:0:1   <--- AWS에 배포(deploy)한 다음에 실행하면, 실제 ip주소를 확인할 수 있음.
  //request.getRemotePort()=54855

메서드	설명
String getRemoteAddr()	요청한 컴퓨터의 IP주소를 반환.
long getContentLength()	요청시 전송한 데이터의 길이를 반환. 길이를 알수 없을 때는 -1을 반환
String getCharacterEncoding()	요청에 포함된 모든 파라미터의 이름을 Enumeration에 담아서 반환
String getContentType()	요청에 포함된 모든 파라미터의 이름과 값을 Map에 담아 반환
String getProtocol()	요청한 클라이언트의 프로토콜과 버전을 반환(HTTP/1.1)
String getMethod()	요청 방식(GET, POST 등)
String getRequestURL()	요청한 URL을 반환(URL전체를 반환) ​
String getRequestURI()	요청한 URI를 반환(URL에서 사이트 주소를 뺀 나머지)
String getContextPath()	요청한 URI가 속한 context path를 반환
String getServletPath()	요청한 URI에서 context path를 제외한 나머지
String getQueryString()	요청에 포함된 쿼리 스트링(query string)을 반환
String getServerName()	요청을 받은 서버의 이름을 반환
int getServerPort()	요쳥을 받은 서버가 사용한 포트를 반환

a.jsp → b.jsp

refer → requestURI
어떤 사이트를 통해 왔는지 알 수 있다.

5. page, request, session, application 정리

기본 객체	유효 범위	설명
pageContext	1개 JSP페이지	JSP페이지의 시작부터 끝까지. 해당 JSP 내부에서만 접근가능. 페이지당 1개
request	1+개 JSP페이지	요청의 시작부터 응답까지. 다른 JSP로 전달 가능. 요청마다 1개
session	n개 JSP페이지	session의 시작부터 종료까지(로그인 ~ 로그아웃). 클라이언트마다 1개
application	context 전체	Web Application의 시작부터 종료까지. context내부 어디서나 접근 가능 모든 클라이언트가 공유. context마다 1개

속성 관련 메서드	설명
void setAttribute(String name, Object value)	지정된 값(value)을 지정된 속성 이름(name)으로 저장
Object getAttribute(String name)	지정된 이름(name)으로 저장된 속성의 값을 반환
void removeAttribute(String name)	지정된 이름(name)의 속성을 삭제
Enumeration getAttributeNames()	기본 객체에 저장된 모든 속성의 이름을 반환

9. URL 패턴

@WebServlet으로 서블릿을 URL에 매핑할 때 사용

종류	URL pattern	매칭 URL
1. exact mapping (정확히 일치)	/login/hello.do	http://localhost/ch2/login/hello.do
2. path mapping (경로)	/login/*	http://localhost/ch2/login/ http://localhost/ch2/login/hello http://localhost/ch2/login/hello.do http://localhost/ch2/login/test/
3. extension mapping (확장자)	*.do, *.jsp	http://localhost/ch2/hi.do http://localhost/ch2/login/hello.do
4. default mapping (디폴트)	/	http://localhost/ch2/ http://localhost/ch2/hello.do http://localhost/ch2/login/ http://localhost/ch2/login/hello http://localhost/ch2/login/hello.do

+) 디폴트 예시 : DispatcherServlet, 인코딩 필터

loadOnStartup = 미리 객체 만들어두는 옵션

서블릿은 첫 요청 시 객체 생성(Lazy-init)5

// @WebServlet(urlPatterns = {"/hello", "/hello/*"}, loadOnStartup = 1)
@WebServlet("/hello")
public class HelloServlet extends HttpServlet { }

전체 설정

개별 설정

원래는 default 서블릿이 받도록 되어있는데, 개별 설정에서 DispatcherServelt이 모든 요청을 받도록 덮어씌워져있다.

10. EL(Expression Language)

request 객체에 저장을 해야지만 EL로 읽을 수 있다.

11. JSTL(JSP Standard Tag library)

2. Filter

나오게된 배경 : 코드 분리, 중복 제거

<예시>

• CharacterEncodingFilter

  → 한글 처리를 해준다.(요청과 응답에 두 번)

  원래는 request.setCharacterEncoding(”UTF-8”); 지정해줘야 함

  response도 마찬가지. 이 코드를 서블릿에서 Filter로 옮긴 것

• 로깅

  어떤 요청이 들어왔는지 다 볼 수 있다. → 사용자가 어떤 페이지에서 가장 오래 머물렀는지 통계내기 가능

• Filter 실습

  

Filter1 - 1. 전처리

Filter2 - 1. 전처리

서블릿 - 처리

Filter2 - 3. 후처리

Filter2 - 3. 후처리

17~18. @RequestParam과 @ModelAttribute / RequestMapping

1. @RequestParam

• 요청의 파라미터를 연결할 매개변수에 붙이는 애너테이션, 생략가능

<예제>

• RequestParamTest.java

  package com.fastcampus.ch2;
  
  import java.util.Date;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.ExceptionHandler;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  
  @Controller
  public class RequestParamTest {
      // ExceptionHandler 애너테이션이 붙으면, 괄호안의 예외 발생 시 이 메서드가 호출된다.
      @ExceptionHandler(Exception.class)
      public String catcher(Exception ex) {
          return "yoilError";
      }
  
      @RequestMapping("/requestParam")
      public String main(HttpServletRequest request) {
          String year = request.getParameter("year");
  //		http://localhost/ch2/requestParam         ---->> year=null
  //		http://localhost/ch2/requestParam?year=   ---->> year=""
  //		http://localhost/ch2/requestParam?year    ---->> year=""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam2")
  //	public String main2(@RequestParam(name="year", required=false) String year) {   // 아래와 동일
      public String main2(String year) {
  //		http://localhost/ch2/requestParam2         ---->> year=null
  //		http://localhost/ch2/requestParam2?year    ---->> year=""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam3")
  //		public String main3(@RequestParam(name="year", required=true) String year) {   // 아래와 동일
      public String main3(@RequestParam String year) {
  //		http://localhost/ch2/requestParam3         ---->> year=null   400 Bad Request. required=true라서
  //		http://localhost/ch2/requestParam3?year    ---->> year=""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam4")
      public String main4(@RequestParam(required = false) String year) {
  //		http://localhost/ch2/requestParam4         ---->> year=null
  //		http://localhost/ch2/requestParam4?year    ---->> year=""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam5")
      public String main5(@RequestParam(required = false, defaultValue = "1") String year) {
  //		http://localhost/ch2/requestParam5         ---->> year=1
  //		http://localhost/ch2/requestParam5?year    ---->> year=1
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
  // =======================================================================
  
      @RequestMapping("/requestParam6")
      public String main6(int year) {
  //		http://localhost/ch2/requestParam6        ---->> 500 java.lang.IllegalStateException: Optional int parameter 'year' is present but cannot be translated into a null value due to being declared as a primitive type. Consider declaring it as object wrapper for the corresponding primitive type.
  //		http://localhost/ch2/requestParam6?year   ---->> 400 Bad Request, nested exception is java.lang.NumberFormatException: For input string: ""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam7")
      public String main7(@RequestParam int year) {
  //		http://localhost/ch2/requestParam7        ---->> 400 Bad Request, Required int parameter 'year' is not present
  //		http://localhost/ch2/requestParam7?year   ---->> 400 Bad Request, nested exception is java.lang.NumberFormatException: For input string: ""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam8")
      public String main8(@RequestParam(required = false, defaultValue = "2021") int year) { // 필수값 아님 그래서 서버 오류 필수가 아니기 때문에 이 값이 안 들어왔을 때의 대비가 되어있어야 한다.
          //	http://localhost/ch2/requestParam8        ---->> 500 java.lang.IllegalStateException: Optional int parameter 'year' is present but cannot be translated into a null value due to being declared as a primitive type. Consider declaring it as object wrapper for the corresponding primitive type.
          //	http://localhost/ch2/requestParam8?year   ---->> 400 Bad Request, nested exception is java.lang.NumberFormatException: For input string: ""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam9")
      public String main9(@RequestParam(required = true) int year) {
          //	http://localhost/ch2/requestParam9        ---->> 400 Bad Request, Required int parameter 'year' is not present
          //	http://localhost/ch2/requestParam9?year   ---->> 400 Bad Request, nested exception is java.lang.NumberFormatException: For input string: ""
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam10")
      public String main10(@RequestParam(required = true, defaultValue = "1") int year) {
          //	http://localhost/ch2/requestParam10        ---->> year=1
          //	http://localhost/ch2/requestParam10?year   ---->> year=1
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  
      @RequestMapping("/requestParam11")
      public String main11(@RequestParam(required = false, defaultValue = "1") int year) {
  //		http://localhost/ch2/requestParam11        ---->> year=1
  //		http://localhost/ch2/requestParam11?year   ---->> year=1
          System.out.printf("[%s]year=[%s]%n", new Date(), year);
          return "yoil";
      }
  } // class

• 애너테이션 안 붙이면 필수값 아님

  http://localhost/requestParam2 → year=null

  http://localhost/requestParam?year → year=“”

  @RequestMapping("/requestParam2")
  // public String main2(@RequestParam(name = "year", required = false) String year) { 아래와 동일 
  public String main2(String year) {
  		... // 애너테이션 안 붙이면 필수값 아님
  }

• 애너테이션 붙이면 필수값

  http://localhost/requestParam3 → year=null // 400 Bad Request. required=true라서

  → 클라이언트 잘못. 요청한 사람이 줘야 할 값을 안줌

  http://localhost/requestParam3?year → year=“”

  @RequestMapping("/requestParam3")
  // public String main3(@RequestParam(name = "year", required = true) String year) { // 아래와 동일
  public String main3(@RequestParam String year) {
        // 애너테이션 붙이면 필수값
  }

• YoilTellerMVC2.java

  package com.fastcampus.Test;
  
  import java.util.Calendar;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.ExceptionHandler;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  
  @Controller
  public class YoilTellerMVC2 {
      @ExceptionHandler(Exception.class)
      public String catcher(Exception ex) {
          return "yoilError";
      }
  
      @RequestMapping("/getYoilMVC2") // http://localhost/ch2/getYoilMVC2
      public String main(@RequestParam(required = true) int year,
                         @RequestParam(required = true) int month,
                         @RequestParam(required = true) int day, Model model) {
  
          // 1. 유효성 검사
          if (!isValid(year, month, day))
              return "yoilError";  // 유효하지 않으면, /WEB-INF/views/yoilError.jsp로 이동
  
          // 2. 처리
          char yoil = getYoil(year, month, day);
  
          // 3. Model에 작업 결과 저장
          model.addAttribute("year", year);
          model.addAttribute("month", month);
          model.addAttribute("day", day);
          model.addAttribute("yoil", yoil);
  
          // 4. 작업 결과를 보여줄 View의 이름을 반환
          return "yoil"; // /WEB-INF/views/yoil.jsp
      }
  
      private char getYoil(int year, int month, int day) {
          Calendar cal = Calendar.getInstance();
          cal.set(year, month - 1, day);
  
          int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
          return " 일월화수목금토".charAt(dayOfWeek);
      }
  
      private boolean isValid(int year, int month, int day) {
          if (year == -1 || month == -1 || day == -1)
              return false;
  
          return (1 <= month && month <= 12) && (1 <= day && day <= 31); // 간단히 체크
      }
  
  }

예외처리

필수 입력 O ⇒ 예외처리

필수 입력 X ⇒ 기본값을 줘야 한다.

// ExceptionHandler 애너테이션이 붙으면, 괄호안의 예외 발생 시 이 메서드가 호출된다.
@ExceptionHandler(Exception.class)
public String catcher(Exception ex) {
    return "yoilError";
}

로그 레벨 중에 trace가 가장 자세한 레벨이다.

<logger name="org.springframework.web">
	<level value="trace" />
</logger>

info -> trace 변경

이제는 예제 YoilTellerMVC2 에서 year, month, day를 하나로 합쳐보자

입력받는 값들이 많을 때는 매개변수의 개수를 줄이기 위해서 클래스를 하나 정의해두고 이 매개변수로 하나로 처리할 수 있다.

장점 : 매개변수로 받을 값들이 줄어들거나 많아져도 코드 바꿀 필요 X MyDate만 변경하면됨. 변경에 유리한 코드가 된다.

public String main(int year, int month, int day, Model model) // 기존
public String main(MyDate date, Model model) // 변경

• YoilTellerMVC4.java (year, month, day를 myDate 클래스로 합친 예제)

  package com.fastcampus.ch2;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.ExceptionHandler;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  
  import java.util.Calendar;
  
  @Controller
  public class YoilTellerMVC4 {
      @ExceptionHandler(Exception.class)
      public String catcher(Exception ex) {
          return "yoilError";
      }
  
      // 많은 매개변수를 적어주어야 할 때는 새로운 클래스를 정의해서 매개변수의 개수를 줄일 수 있다.
      @RequestMapping("/getYoilMVC4") // http://localhost/ch2/getYoilMVC2
      public String main(MyDate date, Model model) {
  
          // 1. 유효성 검사
          if (!isValid(date))
              return "yoilError";  // 유효하지 않으면, /WEB-INF/views/yoilError.jsp로 이동
  
          // 2. 처리
          char yoil = getYoil(date);
  
          // 3. Model에 작업 결과 저장
          model.addAttribute("myDate", date);
          model.addAttribute("yoil", yoil);
  
          // 4. 작업 결과를 보여줄 View의 이름을 반환
          return "yoil"; // /WEB-INF/views/yoil.jsp
      }
  
      private boolean isValid(MyDate date) {
          return isValid(date.getYear(), date.getMonth(), date.getDay());
      }
  
      private char getYoil(MyDate date) {
          return getYoil(date.getYear(), date.getMonth(), date.getDay());
      }
  
      private char getYoil(int year, int month, int day) {
          Calendar cal = Calendar.getInstance();
          cal.set(year, month - 1, day);
  
          int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
          return " 일월화수목금토".charAt(dayOfWeek);
      }
  
      private boolean isValid(int year, int month, int day) {
          if (year == -1 || month == -1 || day == -1)
              return false;
  
          return (1 <= month && month <= 12) && (1 <= day && day <= 31); // 간단히 체크
      }
  }

❓입력되는 값이 year, month, day인데 전혀 관계 없는 타입의 MyDate를 선언해도 이걸 다 알아서 넣어준다고?

아래의 예제를 보면 어떻게 처리되는지 알 수 있다.

• SetterCall.java

  package com.fastcampus.ch2;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.springframework.util.StringUtils;
  
  public class SetterCall {
      public static void main(String[] args) throws Exception{
          Map<String, String> map = new HashMap<>();
          map.put("year", "2021");
          map.put("month", "10");
          map.put("day", "1");
  
          Class<?> type = Class.forName("com.fastcampus.ch2.MyDate");
  
          // MyDate인스턴스를 생성하고, map의 값으로 초기화한다.
          Object obj = dataBind(map, type);
          System.out.println("obj="+obj); // obj=[year=2021, month=10, day=1]
      } // main
  
      private static Object dataBind(Map<String, String> map, Class<?> clazz) throws Exception {
          // 1. MyDate인스턴스 생성
  //		Object obj = clazz.newInstance(); // deprecated method
          Object obj = clazz.getDeclaredConstructor().newInstance(new Object[0]);
  
          // 2. MyDate인스턴스의 setter를 호출해서, map의 값으로 MyDate를 초기화
          // 	 2-1. MyDate의 모든 iv를 돌면서 map에 있는지 찾는다.
          // 	 2-2. 찾으면, 찾은 값을 setter로 객체에 저장한다.
          Field[] ivArr = clazz.getDeclaredFields();
  
          for(int i=0;i<ivArr.length;i++) {
              String name = ivArr[i].getName();
              Class<?>  type = ivArr[i].getType();
  
              // map에 같은 이름의 key가 있으면 가져와서 setter호출
              Object value = map.get(name); // 못찾으면 value의 값은 null
              Method method = null;
  
              try {   // map에 iv와 일치하는 키가 있을 때만, setter를 호출
                  if(value==null) continue;
  
                  method = clazz.getDeclaredMethod(getSetterName(name), type); // setter의 정보 얻기
                  System.out.println("method="+method);
                  method.invoke(obj, convertTo(value, type)); // obj의 setter를 호출
              } catch(Exception e) {
                  e.printStackTrace();
              }
          }
  
          System.out.println(Arrays.toString(ivArr));
  
          return obj;
      }
  
      private static Object convertTo(Object value, Class<?> type) {
          // value의 타입과 type의 타입이 같으면 그대로 반환
          if(value==null || type==null || type.isInstance(value))
              return value;
  
          // value의 타입과 type이 다르면, 변환해서 반환
          if(String.class.isInstance(value) && type==int.class) // String -> int
              return Integer.valueOf(""+value);
  
          return value;
      }
  
      // iv의 이름으로 setter의 이름을 만들어서 반환하는 메서드("day" -> "setDay")
      private static String getSetterName(String name) {
  //		return "set"+name.substring(0,1).toUpperCase()+name.substring(1);
          return "set" + StringUtils.capitalize(name); // org.springframework.util.StringUtils
      }
  }
  
  /*
  [실행결과]
  method=public void com.fastcampus.ch2.MyDate.setYear(int)
  method=public void com.fastcampus.ch2.MyDate.setMonth(int)
  method=public void com.fastcampus.ch2.MyDate.setDay(int)
  [private int com.fastcampus.ch2.MyDate.year, private int com.fastcampus.ch2.MyDate.month, private int com.fastcampus.ch2.MyDate.day]
  obj=[year=2021, month=10, day=1]
   */

1. 요청한 값들이 HashMap으로 들어온다.(담긴다.)

2. MyDate라는 타입이 있을 때 bind()메서드가 Map하고 연결해준다.

   1) 타입으로 넘어온 클래스 정보를 가지고 객체를 만든다.

   2) MyDate 인스턴스의 setter를 호출해서, Map의 값으로 MyDate를 초기화한다.

   2-1. myDate의 모든 iv를 돌면서 Map에 존재하는지 찾는다.

   2-2. 찾으면, 찾은 값을 setter로 객체에 저장한다.

   → setter가 없으면 스프링이 자동으로 처리해주지 못함. setter 필수.

2. @ModelAttribute

• 적용 대상을 Model의 속성으로 자동 추가해주는 애너테이션

• 반환 타입 or Controller 메서드의 매개변수에 적용 가능

//public String main(@ModelAttribute("myDate") MyDate date, Model m) { // 아래와 동일
public String main(@ModelAttribute MyDate date, Model m) { // 참조형 매개변수인 경우에 @ModelAttribute 생략 가능
//public String main(MyDate date, Model m) {
	    char yoil = getYoil(data);
	
	    // 3. Model에 작업한 결과를 저장
	    m.addAttribute("myDate", date); // 
	    m.addAttribute("yoil", yoil);
	
	    // 4. 작업 결과를 보여줄 뷰의 이름을 반환
	    return "yoil";
	}

  private @ModelAttribute("yoil") char getYoil(MyDate date) { // 메서드가 자동으로 호출되고 이 결과가 model에 저장된다.
      return getYoil(date.getYear(), date.getMonth(), date.getDay());
  }

컨트롤러의 매개변수에 붙이는 애너테이션

1. @RequestParam : 기본형, String(생략 가능)

   참조형 매개변수의 경우에는 이 애너테이션 못 붙임. 여러 값이 바인딩되기 때문.

   기본형이나 String 같은 경우 굳이 모델에 저장할 필요X 뷰에서 ${param.파라미터이름}으로 바로 사용 가능하기 때문이다.

2. @ModelAttribute : 참조형(생략 가능, 기본적으로 붙어있다고 보면됨)

3. WebDataBinder

: 브라우저를 통해서 요청받은 값이 실제 객체에 Binding될 때 중간 역할을 해주는 것

String으로 넘어온 걸 변환해주고 검증해주는 애

역할

1. 타입 변환

2. 데이터 검증

3. 결과(BindingResult에 저장)

4. Controller에 넘겨준다.

보통은 컨트롤러 메서드가 받을 수 있는데 지금은 브라우저에서 직접 url을 치고 한번에 들어왔기 때문에 컨트롤러까지 못가고 그 앞에서 에러가 발생해 핸들러로 처리를 한 것. 일반적인 경우는 아님.

일반적인 경우는 form으로 받는 경우고. 그럴 때는 컨트롤러의 BindingResult로 값이 다 넘어올 수 있다. 아래 예제는 예외적인 경우

에러가 발생해도 result로 Controller에서도 결과 보기 가능

• YoilTellerMVC6.java

  package com.fastcampus.ch2;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.validation.BindingResult;
  import org.springframework.validation.FieldError;
  import org.springframework.web.bind.annotation.ExceptionHandler;
  import org.springframework.web.bind.annotation.ModelAttribute;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  import java.util.Calendar;
  
  @Controller
  public class YoilTellerMVC6 {
      @ExceptionHandler(Exception.class)
      public String catcher(Exception ex, BindingResult result) { // BindingResult가 에러 객체를 가지고 있고 에러 객체로부터 어떤 값들을 얻을 수 있는지 보려고 하ㅡㄴ 것
          System.out.println("result = " + result);
  
          FieldError error = result.getFieldError();
          System.out.println("error.getCode() = " + error.getCode());
          System.out.println("error.getField() = " + error.getField());
          System.out.println("error.getDefaultMessage() = " + error.getDefaultMessage());
  
          ex.printStackTrace();
          return "yoilError";
      }
  
      // 많은 매개변수를 적어주어야 할 때는 새로운 클래스를 정의해서 매개변수의 개수를 줄일 수 있다.
      @RequestMapping("/getYoilMVC6") // http://localhost/ch2/getYoilMVC5
  //    public String main(@ModelAttribute("myDate") MyDate date, Model model) { // 아래와 동일
      public String main(MyDate date, BindingResult result) { // key 생략 시 타입의 첫 글자를 소문자로 한 걸 key로 사용.
          System.out.println("result" + result);
  
          // 1. 유효성 검사
          if (!isValid(date))
              return "yoilError";  // 유효하지 않으면, /WEB-INF/views/yoilError.jsp로 이동
  
          // 2. 처리
  //        char yoil = getYoil(date);
  
          // 3. Model에 작업 결과 저장
  //        model.addAttribute("myDate", date);
  //        model.addAttribute("yoil", yoil);
  
          // 4. 작업 결과를 보여줄 View의 이름을 반환
          return "yoil"; // /WEB-INF/views/yoil.jsp
      }
  
      private boolean isValid(MyDate date) {
          return isValid(date.getYear(), date.getMonth(), date.getDay());
      }
  
      private @ModelAttribute("yoil") char getYoil(MyDate date) { // 메서드가 자동으로 호출되고 이 결과가 model에 저장된다.
          return getYoil(date.getYear(), date.getMonth(), date.getDay());
      }
  
      private char getYoil(int year, int month, int day) {
          Calendar cal = Calendar.getInstance();
          cal.set(year, month - 1, day);
  
          int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
          return " 일월화수목금토".charAt(dayOfWeek);
      }
  
      private boolean isValid(int year, int month, int day) {
          if (year == -1 || month == -1 || day == -1)
              return false;
  
          return (1 <= month && month <= 12) && (1 <= day && day <= 31); // 간단히 체크
      }
  }

Uploaded by N2T