**MVC(Model View Controller)패턴
=> 애플리케이션의 역할을 3가지로 분리해서 구현하는 패턴
=> Model : 비지니스 로직을 처리하고 결과를 생성하는 영역
=> View : Model이 생성한 결과를 출력하는 영역
=> Controller : Movel과 Viewe를 연결시켜주는 영역
=> Model2 : Presentation 영역의 코드와 Business Logic 영역의 코드를 분리
- Java Web Application : Presentation Logic은 jsp파일, Business Logic은 java파일에 작성
1. 장점
=> 유지보수가 편리
2. 단점
=> 구현이 어려워질수 있음
3. Controller를 2단계로 구성하는 경우
1) FrontController : 클라이언트의 모든 요청을 받아서 처리하려고 하는 Controller
2) PageController : 클라이언트의 요청 1개나 아니면 하나의 서비스를 처리하기 위한 Controller
4. Spring 프로젝트 구조
=> 웹 브라우저나 웹 요청(request) -> Web Server(Apache) -> Web Application Server(Web Container - tomcat)
-> Front Controller -> PageController -> Service -> DAO -> DataBase Framework -> DataBase
=> Web Server : 사용자의 요청이 오면 요청에 응답할 수 있는 View를 찾아서 리턴하는 역할
- 단순한 HTML로 구성된 것을 요청하면 HTML을 찾아서 리턴할수 있음
=> Web Application Server : Web Server가 처리 요청시, 수행가능한 Server Application이나 로직을 호출하여 결과
출력 후 HTML로 변환하여 WebServer에게 전달
=> 금융업무처럼 온라인 트랜잭션 처리가 잦은 곳에서는 DataBase 앞에 별도의 MiddelWare를 추가
=> 실제 업무 처리에서는 Service를 여러 계층으로 분리
**Spring MVC에서 제공하는 Annotation
1. @Controller, @Service, @Repository, @Compmonet : Bean을 자동 생성해주는 Annotation
2. @Autowired, @Injection, @Resource : 외부에서 자동으로 주입받기 위한 Annotation
3. @RequestMapping
=> Controller 클래스에서 클라이언트의 요청과 호출할 메소드를 매핑해주는 Annotation
4. @RequestParam
=> 클라이언트에서 전달한 파라미터를 매핑하기 위한 Annotation
5. @RequestHeader
=> 클라이언트에서 전달한 헤더를 매핑하기 위한 Annotation
6. @PathVariable
=> 디렉토리 패턴에서 URL의 원하는 부분을 추출하기 위해 사용하는 Annotation
7. @CookieValue
=> 쿠키 정보를 매핑하기 위해 사용하는 Annotation
8. @ModelAttribute
=> View에게 데이터를 전달할 때 사용하는 Annotation
=> 공통된 데이터를 전달하기 위한 목적, 전달되는 파라미터의 이름을 변경하기 위해 사용
9. @SessionAttribute
=> Session에게 데이터를 저장하기 위한 Annotation
10. @InitBinder
=> 파라미터를 수집하여 객체로 만들고자 하는 경우 사용하는 Annotation
11. @ResponseBody
=> 리턴 타입을 HTTP 응답 메시지로 사용하는 Annotation
12. @RequestBody
=> 요청 문자열을 그대로 파라미터로 전달하는 Annotation
**Spring MVC의 주요 구성 요소
1. Dispatcher-Servlet : FrontController의 역할, Spring Bean Configuration 파일로 생성
2. Controller : Page Controller의 역할, POJO(다른 외부 프레임워크의 클래스를 상속받지 않은 순수 자바 객체) 클래스를 만들고 상단에 @Controller라는 어노테이션을 추가하여 생성
3. HandlerMapping : Front Controller에서 Page Controller를 선택하도록 해주는 클래스로 직접 생성할 필요가 없음(Sping이 생성)
4. ModelAndView : Controller가 처리한 결과를 저장하여 뷰를 선택하도록하는 정보와 함께 저장하는 클래스
=> 최근에는 잘 사용하지 않음
5. View Resolver: Controller가 리턴한 View이름을 가지고 실제 출력할 View 파일을 결정하는 클래스
=> Forwarding 시만 적용되고 Redirect시는 비적용
6. View : 실제 출력될 결과 화면
**Spring MVC Project
1. Spring MVC Project 생성
[File] - [New] - [Spring Project] - [Spring Lagacy Project]를 선택하고 [Spring MVC Project]를 선택
=> Project이름을 설정하고 기본패키지(3Level 이상)를 설정
- 패키지 이름에서 3번째 부분이 자동으로 Context Path로 설정되고 이 프로젝트를 war 파일로 작성
- 외부에서 열면 그때는 프로젝트 명이 Context Path로 설정
2. Spring MVC Project 실행
=> WAS를 설정하여 실행
**Spring MVC Project의 pom.xml 설정 변경
1. properties 태그에서 java버전과 Spring버전을 설정
=> properties는 하단에서 자주 사용할 문자열의 이름을 등록해놓은 태그
=> java version은 1.8이상으로 설정 : 람다와 스트림 API를 1.8버전 부터 사용가능
=> Spring version은 4버전이상으로 설정하는 것이 일반적 : Spring 4 부터 RestController를 제공
- REST API : 동일한 서비스를 제공하는 URL은 모두 동일해야 함. 요청시 JSON이나 XML로 응답하여 클라이언트
에서 파싱하여 뷰를 만들어내는 방식
<properties>
<java-version>1.8</java-version>
<org.springframework-version>5.0.7.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
2. repositories
=> Maven 중앙저장소가 아닌곳에서 외부 라이브러리를 다운로드 받고자 하는 경우 설정하는 태그
=> Oracle을 사용할 때만 우리는 사용
=> 기업에서는 기업별로 별도의 저장소가 만들어져 있고 그 곳을 설정
3. dependecies
=> 사용할 외부 라이브러리의 의존성(외부라이브러리를 다운받고 자동으로 build path에 추가)을 설정
=> node.js나 최근의 프레임워크들은 대부분 이방식을 이용하여 외부 라이브러리의 의존성을 결정
=> junit의 버전을 4.12이상으로 변경 - Spring 5.0이상에서는 junit이 4.12 이상인 경우에만 Test 가능
- junit : 단위테스트를 지원하는 자바 라이블러리
1) 단위테스트를 수행하려면 Spring-Test 라이브러리가 있어야 함
=> Spring-test라이브러리의 의존성을 추가
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework-version}</version>
</dependency> 2) HttpServlet 과 jsp 버전을 변경
=> HttpServlet: JavaEE에서 제공하는 URL 요청에 응답할 수 있는 Java Class, WAS 가 호출할 수 있는 클래스
=> JSP(Java Server Pages): HttpServlet 에 출력을 쉽게 할 수 있도록 만든 클래스, HTML 에 Java 코드를 스크립트 형
태로 삽입, 작성하는 것으로 요청시 HttpServlet 클래스로 변환
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.0</version>
</dependency>
4. build 태그 안의 configuration에서 source와 target 변경
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
5. 실행
6. Project를 진행 할 때는 1~4까지는 직접 수행하지 않음
=> Spring MVC Project는 대부분 여러 개발자가 같이 진행하므로 한명이 모든 프로젝트 설정을 하고 설정에 대하여 설명한 후 동일한 설정에서 작업을 진행
7. 톰캣을 이용해서 실행한 경우 포트문제 때문에 실행이 안될 때
=> 오라클과 톰캣 모두 기본 설정 포트가 8080이라서 문제가 됨
- Server 디렉토리에서 Server.xml파일을 열어서 8080외의 다른 포트로 변경
=> 포트번호가 음수로 설정된 경우
<Server port="8005" shutdown="SHUTDOWN"> 이 태그에 port 번호가 -1로 설정된 경우 8005번으로 변경
**Spring MVC Project의 구조
1. pom.xml(maven 설정파일)을 제일 먼저 읽어서 실행
=> 이 파일의 내용이 잘못되면 애플리케이션은 실행되지 않음
=> pom.xml을 수정하면 저장후 애플리케이션을 다시 실행하여 잘못된 부분이 있는지 확인
2. web.xml(Java web application 설정파일)을 읽어서 애플리케이션 설정
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>=> listener : 애플리케이션 시작, 종료될때 또는 세션이 생성, 소멸등의 이벤트 발생시 호출될 클래스를 설정
- 이벤트 발생시 호출되는 객체를 Listener라고 함
=> spring mvc project에서 listener 설정만 있는 경우 applicationContext.xml 파일이 Listener 역할을 수행
=> context-param 태그를 이용하여 applicationContext.xml 파일의 경로를 변경 할 수 있음
- contextConfiguration이라는 이름에 파일경로를 설정하면 됨
=> 이 파일에는 공통으로 사용할 bean에 대한 정보를 설정
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>=> servlet-mapping에서는 요청을 처리할 HttpServlet클래스를 설정
- /는 .jsp를 제외한 모든 요청
=> Spring의 DispatcherServlet은 Front-Controller의 역할 수행
- 그 안에 있는 init-param이 DispatcherServlet의 설정 내용을 가지는 파일의 경로를 설정
3. URL 패턴
1) /* : 모든 요청에 해당하는 패턴, 이 패턴은 파라미터 인코딩 설정에 이용
2) / : .jsp를 제외한 모든 요청을 처리
=> 1)과 2)로 설정시 .js, .css, .png와 같은 리소스 요청도 전부 처리하려고 함
- 외부에 자원을 두지 않고 프로젝트 내의 자원을 사용하는 경우 이에대한 해결책을 설정해야 함
3) *.확장자 : 특정한 확장자로 끝나는 요청을 처리, 이전에는 확장자를 do로 많이 처리
=> 공공기관이나 Naver등에서 사용중
4) /디렉토리/ : 특정 디렉토리가 포함된 요청을 처리
=> 최근 '/서비스명/'로 작성후, 뒤에 작업내용을 설정하는 형태로 서비스를 구현하는 곳이 많음
5) /디렉토리/요청경로 : 구체적으로 하나의 요청을 지정(거의 사용하지 않음)
4. Encoding Filter 설정
=> post 방식으로 전송된 파라미터는 인코딩 해서 읽어야 함
- 미 인코딩시 한글이 깨짐
=> java web programming
- 파라미터 읽기 전 HttpServletRequest 객체를 가지고 setCharacterEncoding("utf-8") 메소드 호출
=> spring mvc project : web.xml 파일에 Filter를 설정, 모든 요청을 처리하기 전에 위의 메소드를 호출하도록 설정
**Controller
=> MVC Controller : 요청을 받아 필요한 Business Logic(Service)를 호출하고 그 결과를 받아 View에 전달하는 객체
=> Java Web Programming : HttpServlet 클래스로 생성
Spring MVC Project : POJO 클래스 제작 후, 상단에 @Controller를 추가하여 생성
- @Controller가 추가된 클래스는 Spring 설정파일의 Base Package 안에 만들어져야 함
1. 요청 처리 방법
=> Controller 안에 메소드를 생성하고 위에 @RequestMapping(value="요청URL",method=RequestMethod.GET or
POST)를 추가해 주면 URL 요청이 GET이나 POST로 왔을 때 메소드를 호출
=> 요청방식에 상관없이 호출할 경우 @RequestMapping("요청할 URL")의 형식으로 설정하는 것도 가능
=> 여러개의 요청을 한꺼번에 처리하고자 하면 value={URL, URL...}으로 설정
2. 파라미터 처리방법
=> 기존의 HttpServletRequest 클래스를 이용
- getParameter나 getParameterValues 메소드를 호출하여 처리
- 요청처리 메소드(HttpServletRequest request){ int num = Integer.parseInt(request.getParameter("num")); }
=> @RequestParam을 이용
- @RequestParam("파라미터명") 자료형 변수명
- 자료형 변환이 자동으로 이루어짐
- 요청처리 메소드(@RequestParam("num") int num){ }
=> Command 객체를 이용
- 파라미터로 구성된 Class제작 후, 클래스 변수를 매개변수로 받으면 파라미터가 Command 프로퍼티에 자동대입
- 파라미터의 이름과 프로퍼티의 이름이 같아야 함
3. 파라미터 처리 실습
1) home.jsp 파일에 링크를 추가
=> 기존 home.jsp 파일을 삭제하고 재 생성
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>MVC 실습</title>
</head>
<body>
<a href="">파라미터 입력</a>
</body>
</html>
2) HomeController 클래스에 form요청이 Get으로 왔을 때 처리하는 메소드를 생성
//form 요청을 GET으로 전송했을 때 처리할 메소드
@RequestMapping(value="form", method=RequestMethod.GET)
public String form() {
//단순 페이지 이동은 jsp 파일의 이름만 리턴하면 됨
return "form";
}
3) WEB-INF/views 디렉토리에 form.jsp파일을 만들고 작성
=> 웹 사이트만 만드는 경우에는 form을 만들고 전송 버튼을 만들어 전송하면 됨
- 모든 디바이스 요청을 처리하는 서버를 만들경우 ajax로 요청해야 함
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>파라미터 전송</title>
</head>
<body>
<!-- action은 생략하면 이 페이지에 오게된 요청 : form
method는 생략하면 get
enctype은 file이 있을 때만 multipart/form-data를 설정 -->
<form id="paramform" method="post">
이름 :<input type="text" name="name" id="name"/><br/>
전화번호 :<input type="text" name="phone" id="phone"/><br/>
나이 :<input type="text" name="age" id="age"/><br/>
<!-- 비권장(버튼으로 처리) -->
<input type="submit" value="전송" />
<!-- 권장(ajax로 처리) -->
<input type="button" value="전송" id="ajaxbtn"/>
</form>
</body>
</html>
4) 애플리케이션을 실행해서 입력화면까지 이동하는 지 확인
5) formController 클래스에 form요청을 post로 전송한 경우 처리할 메소드 작성
@RequestMapping(value="form", method=RequestMethod.POST)
//기존의 HttpServletRequest를 이용한 파라미터 처리를 위한 메소드
public String form(HttpServletRequest request) {
String name = request.getParameter("name");
String phone = request.getParameter("phone");
String age = request.getParameter("age");
//출력
System.out.println("이름 : " + name);
System.out.println("전화번호 : " + phone);
System.out.println("나이 : " + age);
return "result";
}
6) 위의 요청 처리 메소드 수정
@RequestMapping(value="form", method = RequestMethod.POST)
//@RequestParam을 이용한 파라미터 처리를 위한 메소드
//Spring에서 파라미터 처리를 할 때 많이 사용하는 방법
//동일한 이름의 파라미터가 여러 개 있으면 List 나 배열로 받는 것도 가능
public String form(
@RequestParam("name") String name,
@RequestParam("phone") String phone,
@RequestParam("age") int age) {
//출력
System.out.println("이름:" + name);
System.out.println("전화번호:" + phone);
System.out.println("나이:" + age);
return "result";
}7) command 객체를 이용하는 방법
=> name, phone, age를 저장할 수 있는 Command Class를 생성
=> 자료형과 이름을 잘 맞춰야 함
package com.pk.mvc.domain;
public class User {
private String name;
private String phone;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", phone=" + phone + ", age=" + age + "]";
}
}=> 요청 처리 메소드를 수정
@RequestMapping(value="form", method = RequestMethod.POST)
//Command 객체를 이용하는 방법
public String form(User user) {
//출력
System.out.println(user);
return "result";
}
4. @PathVariable
=> 최근의 상세보기 구현에서는 파라미터를 사용하지 않는 경우가 있음
=> 디렉토리 패턴에서 사용하는데 /데이터의 형식으로 넘겨줌
=> 블로그 형 게시판에서 많이 사용
=> Spring의 Controller에서 마지막 부분을 읽어내고자 할때 사용하는 어노테이션이 @PathVariable
https://ggangpae1.tistory.com/286?category=840479
=> @RequsetMapping(value="{num}")
요청처리메소드(@PathVariable("num") int num)
http://www.bloter.net/archives/394057
=> @RequsetMapping(value="achives/{num}")
요청처리메소드(@PathVariable("num") int num)
5. PathVariable 실습
1) home.jsp 파일에 요청을 생성
<a href="detail/170">Path Variable</a><br/>
2) HomeController 클래스에 위의 요청을 처리하는 메소드를 생성
@RequestMapping(value="detail/{num}", method = RequestMethod.GET)
//경로를 변수로 이용하고자 할 때 읽어내는 방법 : 최근의 블로그형 게시판에 이용
public String detail(@PathVariable("num") int num) {
//출력
System.out.println(num);
return "result";
}
6. ModelAttribute
=> Controller 클래스 메소드에 어노테이션을 설정하고 메소드가 리턴시, 리턴되는 데이터가 모든 View에 전송
@ModelAttribute("msg")
public String result(){
return "Hello Common String";
}=> 이 메소드가 있는 Controller의 모든 View에게는 msg 라는 이름으로 Hello Common String이 attribute로 전달
=> Command 객체로 파라미터를 받으면 Command 객체로 받은 내용이 다음 View에게 클래스 이름의 첫글자를 소
문자로 변경한 것으로 전송
- 이름을 변경해서 넘기려면 Command 객체 앞에 @ModelAttribute("별명") 클래스 변수명의 형태로 받으면 됨
=> Command 객체: 파라미터들을 묶어서 전송받기 위한 클래스의 객체 Spring에서 유효성 검사 할 때 유용
=> 유효성 검사시, 서버에서 유효성 검사를 한 경우 검사 실패시 Spring에서는 Command 객체를 이용해서 해결
7. InitBinder
=> 메소드 위에 @InitBinder를 추가하고 데이터 형식을 설정하면 형식에 맞는 데이터가 오면 자동 변환
@InitBinder
public void initBinder(WebDataBinder binder){
SimpleDateFormat sdf = new SimpleDateFormat("날짜 형식");
Biner.registerCustomEditor(java.util.Date.class, new CustomDateEditor(sdf, false));
}=> 날짜 형식의 문자열이 오면 java.util.Date 형식으로 변환
8. @DateTimeFormat
=> Command 객체 클래스 제작시 Date 타입이 있는 경우 Date 타입위에 @DateTimeFormat(pattern="날짜형식")으
로 설정하면 날짜 형식의 문자열이 오면 Date 타입으로 변경
9. Controller 요청 처리 메소드의 매개변수
=> Java Web Application HttpServlet의 처리 메소드는 HttpServletRequest, HttpServletResponse 매개변수를 가짐
=> Spring에서는 요청처리 메소드의 매개변수를 다양한 형태로 만들수 있음
1) HttpServletRequest, HttpServletResponse 사용 가능
2) HttpSession 사용 가능
3) Locale : 현재 요청에 대한 지역(국가 설정) 정보
4) Reader, Writer : 읽고 쓰기를 스트림을 이용해서 직접 하고자 할 때 사용
5) Map, Model, ModelMap : View 페이지에 데이터를 전송하고자 할 때 사용
6) @RequestParam, @RequestHeader
=> 파라미터나 헤더 정보를 받고자 할 때 사용
=> @RequestHeader는 OpenAPI서버를 직접 구현하고자 할 때 사용
7) @CookieValue
=> 쿠키값을 읽어내고자 할 때 사용
=> 보안 문제로 사용하지 않는 것을 권장했다가 최근 사용자의 요청 흐름 파악에 쿠키를 이용하는 경우가 많아짐
8) @PathVariable
=> URL에 변수를 추가한 형태일때 변수를 읽기 위한 파라미터
9) Errors, BindResult : 데이터 유효성 검사를 할 때 사용
10) Command 객체
11) @RedirectAttributes : 리다이렉트 할 때 1번만 전달되는 데이터를 생성할 때 사용
(ex - 로그인에 성공하였습니다. 회원가입에 성공하였습니다.등 메시지 출력)
10. Controller의 요청 처리 메소드의 리턴 타입
1) ModelAndView : 출력할 View이름과 출력할 데이터를 1개로 묶어주는 클래스
2) Model, Map : 출력할 데이터만 생성해서 리턴, 뷰이름은 요청 URL로 설정
3) String : 뷰 이름을 리턴, 출력할 데이터가 있으면 메소드의 매개변수로 Map이나 Model을 만들어서 저장
4) View : View를 직접 만들어서 출력 - 파일 다운로드 같은 곳에서 이용
5) void : 요청과 동일한 이름의 뷰로 출력할 때 사용 - 단순 페이지 이동에 사용
6) VO나 DTO 또는 List : JSON출력하고자 하는 경우 사용
7) HttpHeaders : 단순하게 헤더만 만들어서 전송하고자 할때 사용 - API 요청이 실패했을 때
8) ResponseEntity : Http 헤더와 내용을 가공하고자 할 때 사용
=> 3, 5, 6번이 초반에는 중요
11. View 설정
=> 출력할 뷰는 Controller에서 리턴한 문자열과 ViewResolver 설정을 합쳐서 결정
=> 기본 이동방법은 Forwarding
=> ViewResolver 설정은 appServlet 디렉토리에 있는 spring 설정 파일에 존재
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
</beans:bean>=> 시작 요청의 경우 /이외에 index.html, default.html 까지 처리해 주는 것이 일반적
=> redirect를 하고자 하는 경우 view이름앞에 redirec: 를 추가
=> redirect를 하게 되면 ViewResolver와 관계없이 동작
- redirect를 사용할 때는 외부 도메인으로 가던가 Controller로 다시 돌아오도록 해야 함
- redirect 할때 특정 View페이지로 직접 이동하지 않도록 해야 함
=> redirect 하는 경우는 작업을 수행한 경우이고, forwarding하는 경우는 조회를 하는 경우
=> 웹 페이지를 만드는 것이 아니라면 전부 forwarding
- iOS, Android, WebBrowser 요청을 하나의 서버에서 하려면 뷰를 보여주는 것이 아니고 데이터를 리턴하는 경우
- Web Browser에서는 전부 ajax로 요청하고, javascript 코드를 이용해서 페이지 이동을 해야 함
=> 웹 애플리케이션을 기획할 때
- 하나의 서버 애플리케이션으로 모두 지원할경우 AJAX요청을 잘 이해해야 함
- 웹 사이트, 모바일서버를 별도로 만들 경우 AJAX는 유효성 검사만 할수 있으면 됨
12. Controller에서 View에게 데이터 전달 : Attribute
1) Model, Map을 요청처리 메소드의 매개변수로 만들고, 데이터 저장시 request의 attribute로 만들어 져서 전달
2) 리턴 타입을 ModelAndView로 만들어서 데이터를 저장하고 리턴시 request의 attribute로 만들어져 전달
3) @ModelAttribute가 붙은 데이터도 View에 전달됨
4) Command 객체
5) session에 저장하는 방법
=> HttpSession을 생성해서 저장
=> RedirectAttribute를 이용해서 한번만 사용하는 데이터를 생성해서 전달
**수업 외 정보
1. 컴파일 하는 언어의 실행과정
=> 소스코드 -> Compile(문법체크) -> 실행되기 직전의 코드(자바 : ByteCode) -> build(앱이 실행할수 있도록 각 운
영체제의 start up 코드나 실행되기 직전의 코드를 모아서 실행가능한 프로그램으로 생성 - target version 설정) ->
Load(메모리에 적재) -> run(실행)
=> 컴파일 언어의 IDE들은 대부분 코드를 수정하고 새로 만들면 자신이 컴파일하여 문법적 오류를 체크
=> Server 애플리케이션은 하나의 Computer에서 실행되기 때문에 이행하지 않으면 그다지 중요치 않음
2. 스크립트 언어
=> 줄단위로 번역하면서 실행
=> 문법적인 에러체크를 하지 않고 실행하면서 에러를 밝생시킴
=> JavaScript, Python, Kotlin, Swift등
3. Cashing
=> 재사용을 빠르게 하기 위해서 로컬에 저장해 두는 것
**Filter - spring에서는 Interceptor, AOP
(AOP : 관점지향 프로그래밍 - 작업의 종류에 따라 프로그래밍 분리 - 비지니스 로직처리와 공통관심 사항으로 분리)
=> 요청을 처리하기 전에 수행할 작업이나, 처리 후 수행할 작업을 설정하는 객체(실제 만드는 것은 클래스)
- IoC(제어의 역전) : 개발자 - 클래스를 만들어 비지니스 로직만 작성, 관리작업은 프레임워크나 컨테이너가 수행
=> Filter를 가지고 작업시, 결과를 내가 원하는 자료형으로 변경하는 Filter를 만드는 것을 Wrapper라고 부름
**Web에서 요청을 전송하는 방식
1. GET
=> 파라미터를 URL 뒤에 붙여서 전송하는 방식
=> 보안이 취약하고 보내는 파라미터 크기에 제한이 있음
=> 요청을 전송하는 기본 방식
2. POST
=> 파라미터를 Header에 숨겨서 전송하는 방식
=> 보안이 우수하고 파라미터 크기에 제한이 없음
=> form에 post라고 설정하거나 ajax요청시 post라고 설정해야 함
**파라미터 생성
=> parameter : 웹에서 요청 전송시 서버에게 전달하는 데이터
1. URL뒤에 ?를 추가하고 파라미터명=값, 파라미터명=값...의 형태로 직접 작성 가능
=> 이 경우 무조건 GET방식으로 전송되는데 목록보기에서 상세보기를 만들때 많이 사용됨
2. form을 만들고 내부에 입력가능한 객체를 생성하여 전송하는 방법
=> 전송할 객체들을 name속성에 서버에서 이용할 이름을 생성해야 함
=> 전송방식으로 GET, POST로 설정하는 것이 가능
=> input에 file, password, textarea 태그가 있으면 반드시 전송방식은 post
=> file이 있는 경우 enctype를 multipart/form-data로 설정
면접 - Ioc, AOP, POZO
'수업 정리' 카테고리의 다른 글
| 63~65일차 수업 정리(Spring MVC Project 외 정리) (0) | 2020.07.08 |
|---|---|
| 63~66일차 수업 정리(Spring MVC Project) (0) | 2020.07.07 |
| 62일차 수업 정리(Spring - Transaction, Hibernate, MyBatis) (0) | 2020.07.03 |
| 61일차 수업정리(Spring - MyBatis) (0) | 2020.07.02 |
| 60일차 수업정리(Spring - lombok) (0) | 2020.07.01 |