✅ 메인보드

• 현재 실행되는 프로그램의 명령어와 데이터를 저장하는 부품
• 프로그램이 실행되기 위해서는 반드시 메모리에 저장되어 있어야 한다
• 메모리는 현재 실행되는 프로그램의 명령어와 데이터를 저장한다
• 메모리에 저장된 값의 위치는 주소로 알 수 있다

✅ CPU

• 컴퓨터의 두뇌
• 메모리에 저장된 명령어를 읽고, 해석하고, 실행하는 부품
• 산술논리연산장치(ALU), 레지스터, 제어장치로 구성되어 있다

🔹 산술논리연산장치(ALU)

• 계산만을 위해 존재하는 부품
• 컴퓨터 내부에서 수행되는 대부분의 계산은 ALU가 도맡아 처리한다

🔹 레지스터

• CPU 내부의 임시저장장치
• 가격이 비싸고 저장용량이 작다
• 전원이 꺼지면 저장된 내용을 잃는다

🔹 제어장치

• 제어신호라는 전기신호를 내보내고 명령어를 해석하는 장치

✅ 보조기억장치

• 전원이 꺼져도 보관될 프로그램을 저장하는 부품
• 하드디스크, SSD, USB메모리, DVD, CD-ROM 등
• 보조기억장치는 관점에 따라 입출력장치의 일종으로 볼 수 있다 => 주변장치라고 통칭하기도 한다

✅ 입출력장치

• 컴퓨터 외부에 연결되어 컴퓨터 내부와 정보를 교환할 수 있는 부품
• 마이크, 마우스, 키보드, 프린터 등

✅ 메인보드(마더보드)

• 컴퓨터의 핵심 부품들을 모아 연결하는 판

✅ 시스템버스

• 메인보드에 연결된 네가지 핵심 부품이 서로 정보를 주고받는 통로
• 주소버스, 데이터버스, 제어버스로 구성되어 있다
• 주소버스 : 주소를 주고 받는 통로
• 데이터버스 : 명령어와 데이터를 주고 받는 통로
• 제어버스 : 제어신호를 주고 받는 통로

• 비동기 자바스크립트와 XML(요즘엔 JSON을 많이 사용)
• 해당 웹 페이지를 새로고침하지 않고 요청을 보내 응답 받은 내용을 현재 페이지에 반영할 수 있는 문법
• 웹페이지 전체를 다시 로딩하지 않고도 웹페이지의 일부분만을 갱신할 수 있고 백그라운드 영역에서 서버와 통신하여 그 결과를 웹페이지의 일부분에만 표시할 수 있다
• 주로 @RestController에 요청을 보내 데이터만 가져와서 활용하는 방식으로 사용한다
• 서버로부터 데이터를 응답받을 때 마다 이벤트가 발생하고 해당 이벤트를 처리하여 사용한다

🍀 XMLHttpRequest

• 자바스크립트의 비동기 통신 요청 객체(AJAX 요청 객체)
• 요청을 보내도 페이지가 새로고침되지 않는다
• 인스턴스를 생성한 후 해당 인스턴스에 여러 설정을 한 뒤 요청을 보낸다
• 웹 브라우저가 서버와 데이터를 교환할 때 사용한다(웹 브라우저가 백그라운드에서 서버와 계속 통신할 수 있는 이유)

🍀 서버에 요청(request)하기

🌼 open(method, url) 메소드

• 서버로 보낼 ajax 요청의 형식을 설정
• 첫 번째 파라미터에는 요청 방식을 설정(GET, POST 방식 중 하나 선택, 이외의 메서드(PUT, DELETE)는 xhttp로만 보낼 수 있다(form으로는 못보냄))
• 두 번째 파라미터에는 요청 URL을 설정한다

🌼 send() 메소드

• 작성된 ajax 요청을 서버로 전달한다
• 전달방식에 따라 인수를 가질수도, 안가질수도 있다(GET방식의 경우는 url로 파라미터를 넘겨주지만 POST인 경우에는 send()에 파라미터를 실어서 넘겨줘야 한다)

※ AJAX에서는 주로 GET방식 보다는 POST방식을 사용하여 요청을 전송한다

🍀 서버에 응답(response)하기

🌼 readyState

• XMLHttpRequest 객체의 현재 상태를 나타낸다
• 객체의 현재 상태에 따라 값이 변화한다

    1. UNSENT(숫자 0) : XMLHttpRequest 객체가 생성됨
    2. OPENED(숫자 1) : open()메서드가 성공적으로 실행됨
    3. HEADERS_RECEIVED(숫자 2) : 모든 요청에 대한 응답이 도착
    4. LOADING(숫자 3) : 요청한 데이터를 처리중
    5. DONE(숫자 4) : 요청한 데이터의 처리가 완료되어 응답할 준비가 완료됨

🌼 status

• 서버의 문서상태를 나타낸다(HTTP 상태코드)

• 1xx : 조건부 응답
• 2xx : 성공(서버에 문서가 존재함)
• 3xx : 리다이렉션 완료
• 4xx : 요청 오류 (404- 서버에 문서가 존재하지 않음)
• 5xx : 서버 오류

🌼 onreadystatechange

• XMLHttpRequest 객체의 readyState 프로퍼티 값이 변할 때 마다 호출되는 이벤트

• 서버에서 응답이 도착할 때까지 readyState프로퍼티 값의 변화에 따라 총 5번 호출된다

• 이 프로퍼티를 이용하면 서버에 요청한 데이터가 존재하고, 서버로부터 응답이 도착하는 순간을 특정할 수 있다

• readyState 0 : XMLHttpRequest 객체가 생성되었을 때

• readyState 1 : open()이 성공했을 때 (send()하기 전)

• readyState 2 : 요청에 대한 응답이 도착했을 때

• readyState 3 : 응답에 대한 처리를 시작했을 때

• readyState 4 : 응답에 대한 처리가 모두 끝났을 때

🍀 서버로부터의 응답 데이터 확인하기

🌼 responseText

• 서버에 요청하여 응답받은 데이터를 문자열로 반환한다
• 서버로부터 텍스트파일을 응답받은 경우에는 responseText를 사용하여 받은 데이터를 문자열로 반환한 후 사용할 수 있다

🌼 responseXML

• 서버에 요청하여 응답받은 데이터를 XML DOM 객체로 반환한다
• 이방법은 잘 안쓴다 ,,, (귀찮음)

🍀 HttpHeader

• 클라이언트와 서버 사이의 통신시 서로에게 전달해야 할 여러 데이터를 포함한다
• AJAX를 사용하여 Http요청 헤더를 직접 설정하거나 Http응답 헤더의 내용을 직접 확인할 수도 있다
• 요청을 보내기 전에 setRequestHeader()메서드를 사용하여 Http요청 헤더를 작성할 수 있다

🌼 HttpRequestHeader(name, value)

• 요청을 보내기 전에 setRequestHeader()메서드를 사용하여 Http요청 헤더를 작성할 수 있다
• name은 Http요청 헤더에 포함하고자 하는 헤더의 이름이며, 값도 함께 전달한다

  🌼 HttpResponseHeader

• 서버로 부터 전달받은 Http응답 헤더 내용을 메서드를 이용하여 확인할 수 있다
• getAllResponseHeaders() : Http응답 헤더의 모든 헤더를 문자열로 반환한다
• getResponseHeader() : Http응답 헤더 중 인수로 전달받은 이름과 일치하는 헤더의 값을 문자열로 반환한다

🌼 Content-Type

• 요청 또는 응답의 데이터가 어떤 형식인지 판단
• 자원의 형식(Media Type)을 명시하기 위해 헤더에 실려서 전송된다
• 기본값은 html문서의 MIME타입인 "text/html"이다

📚 참고자료

✅ Ajax_사용법

• 해당 에러코드 발생시 포워드가 아니라 리다이렉트 처리이므로 컨트롤러에서 별도 처리가 필요하다
  404 /error/notfound

에러 처리 컨트롤러

```java @RequestMapping("/error") @Controller public class ErrorController {

@GetMapping("/notfound")
void notFound() {

}

}

• HTTP URI로 해당 자원을 식별하고 HTTP method로 해당 자원에 대한 CRUD를 구분하여 자원만 응답하는 방식
• HTML 뷰 페이지가 아닌 자원만 응답하기 때문에 웹 브라우저가 아닌 프로그램에서도 서버를 활용할 수 있다는 장점이 있다
• Create, Insert(POST method) POST:/employee - 새 사원을 추가한다
• Read, Select(GET method) GET:/employee/105 - 105번 사원을 조회한다
• *Update (PUT method) * PUT:/employee/183 - 183번 사원을 수정한다
• Delete (DELETE method) DELETE:/employee/170 - 170번 사원을 삭제한다

🍀 Spring REST

• @RestController : 해당 클래스가 RestController임을 표시
• @ResponseBody : 해당 메서드가 뷰 페이지 대신 데이터를 응답한다는 것을 표시
• @RequestBody : 요청에 실려온 데이터를 바인딩해주는 어노테이션
• @PathVariable : 요청 URI의 일부분을 변수의 값으로 활용할 수 있다(일반 컨트롤러에서도 사용 가능)

🍀 @RestController

• 일반 컨트롤러와 다르게 다음 뷰를 가리키는 대신 데이터를 응답한다
• 컨트롤러 내부 메서드의 리턴타입은 뷰를 찾아가는 방식이 아니라 사용자에게 응답할 데이터의 타입을 의미한다
• 주로 JSON방식 또는 XML형식으로 응답하게 된다

🍀 jackson-databind와 jackson-dataformat-xml

• @RestController에서 자바빈 객체를 리턴하면 알아서 JSON(또는 XML)형식으로 변환해 응답해주는 라이브러리
• jackson-databind와 jackson-dataformat-xml의 Maven을 복사하여 pom.xml에 붙여넣기(아래 내용 복사해도 됨)

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.15.2</version>
</dependency>

🌼 RestController에서 사용하기

🌱 json형식으로 변환하기

@RequestMapping("/restful")
@Log4j
@RestController
public class RestSampleController {
    @GetMapping(value="/employee/json", produces = MediaType.APPLICATION_JSON_VALUE)
    public Employee emp1() {
        Employee e = new Employee();
        e.setFirst_name("철수");
        e.setLast_name("김");
        e.setSalary(5000);
        return e;
    }
}

** 📺 출력 결과 >> **

🌱 xml형식으로 변환하기

@RequestMapping("/restful")
@Log4j
@RestController
public class RestSampleController {
    @GetMapping(value="/employee/xml", produces = MediaType.APPLICATION_XML_VALUE)
    public Employee emp2() {
        Employee e = new Employee();
        e.setFirst_name("철수");
        e.setLast_name("김");
        e.setSalary(5000);
        return e;
    }
}

** 📺 출력 결과 >> **

📚 참고자료

restful api

• JavaScript Object Notation
• 언제든지 자바스크립트 오브젝트로 변환할 수 있는 문자열 형식
• 다양한 언어들의 객체로 변환하기에도 편리하기 때문에 객체들의 공용어로 활용되고 있다
• 속성-값 쌍으로 구성되어있다
• 특정 언어에 종속되어있지 않은 공통 규격

🌼 JSONObject

• 자바의 Map처럼 사용할 수 있는 객체
• 해당 객체에 값들을 추가 한 후에 toJSONString()을 호출하여 JSON 형식의 문자열을 얻을 수 있다
• 자바의 기본 배열은 값으로 사용할 수 없다
• 배열을 값으로 추가할 때는 List(또는 JSONArray)로 추가하면 된다
• 객체를 값으로 추가할 때는 Map(또는 JSONObject)으로 추가할 수 있다

🌼 JSONParser

• JSON 형식 문자열을 JSONObject로 변환하는 기능을 가진 클래스
• 문자열로 전달하거나 Reader를 전달하여 사용할 수 있다

🍀 자바에서 JSON을 사용하기

1. 의존성 주입

• json-simple에서 maven을 복사해서 pom.xml에 붙여넣기(아래내용을 붙여넣어도 됨)

  <dependency>
        <groupId>com.googlecode.json-simple</groupId>
        <artifactId>json-simple</artifactId>
        <version>1.1.1</version>
  </dependency>

2. JSON 객체를 생성하여 사용하기

• 자바의 Map을 바로 JSON 형태 문자열로 변환해준다

• 자바스크립트에 배열로 전달하고 싶을 때는 List를 사용한다

• 객체 내부에 객체를 넣을 수 있다

  public class SimpleJsonTest {
    public static void main(String[] args) {
        //JSON객체 생성
        JSONObject obj = new JSONObject();
  
        obj.put("name", "홍길동");
        obj.put("age", 40);
        // JSON으로 생성한 객체 출력
        System.out.println(obj);
  
        Map<String, Object> map = new HashMap<>();
        List<String> hobbies = new ArrayList<>();
        Map<String, Object> car = new HashMap<>();
  
        car.put("carName", "스포티지");
        car.put("carNumber", "12가3456");
        car.put("carAge", 8);
  
        hobbies.add("농구");
        hobbies.add("야구");
        hobbies.add("발야구");
  
        map.put("name", "임꺽정");
        map.put("phone", "123-1234-1234");
        map.put("age", 33);
        map.put("hobby", hobbies);
        map.put("car", car);
  
        // map을 JSON으로 변환하여 출력
        System.out.println(new JSONObject(map));
    }
  

}

** 📺 출력 결과 >> ** 
![](https://velog.velcdn.com/images/blcoding_2023/post/92087335-8ec7-4e99-aac3-bfb6c6fdc43c/image.png)

---
# 🍀 자바스크립트에서 JSON 사용하기
## 🌼 JSON.stringify()
>```js
JSON.stringify(value);

+ 인수로 전달받은 자바스크립트 객체를 문자열로 변환하여 반환한다
+ value에는 변환할 자바스크립트 객체를 전달한다
+ 이 메서드는 UTF-16으로 인코딩된 JSON형식의 문자열을 반환한다

## 🌼 JSON.parse()
>```js
JSON.parse(text);

+ 인수로 전달받은 문자열을 자바스크립트 객체로 변환하여 반환한다
+ text에는 변환할 문자열을 전달한다(text는 유효한 JSON형식의 문자열이여야 함)

---
# 🍀 JSON과 JavaScript Object의 차이점
- JavaScript Object는 문자열 값 또는 key에 ""를 생략할 수 있지만 JSON은 반드시 써야한다
- JavaScript Object는 문자열 값 또는 key에 ''를 쓸 수 있지만 JSON은 ""만 써야한다
- JSON은 문자열 형식의 이름이고 JavaScript Object는 자바스크립트의 인스턴스이다 
---

# 🍀 JSON의 활용
- RestController에서 데이터 application/json 형식으로 응답할 때 사용한다
- JSON 형식의 문자열을 받은 웹 페이지에서 해당 값을 JavaScript Object로 변환하여 페이지 구성에 활용할 수 있다
- 요청시 JSON 형식으로 데이터를 보내 DB에 반영하는 것도 가능하다 (자주 쓰는 방법은 아님)

## 🌼 Parsing 
+ JSON 형식 문자열 -> JSONObject로 만들기

```java
public class SimpleJsonTest {

    public static void main(String[] args) {
        JSONParser parser = new JSONParser();

        try {
            JSONObject parsed = (JSONObject)parser.parse(
                    "{\"fruit\":\"apple\",\"drink\":\"ade\""
                    + "\"flavor\":[3,5,6,11]}");

            System.out.println("JSON 문자열로 객체 만들어서 자바에서 활용하기");
            System.out.println(parsed.get("fruit"));
            System.out.println(parsed.get("drink"));

            List<Integer> flavorNums = (List<Integer>)parsed.get("flavor");

            for(int i = 0; i < flavorNums.size(); i++) {
                System.out.println("flavor["+i+"] : " + flavorNums.get(i));

            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

** 📺 출력 결과 >> **

📚 참고자료

• ✅ mdn공식문서
• ✅ JSON
• ✅ RequestBody란?

• 프로젝트를 구성하는 소스코드들을 계층별로 분리한 것
• 화면 계층(Presentation Layer)
• 비즈니스 계층(Business Layer)
• 영속 계층(Persistence Layer)

🌼 화면 계층

• 화면에 보이는 코드를 작성하는 계층
• 하나의 요청이 여러개의 비즈니스 로직을 요구하거나 하나의 비즈니스 로직이 여러 요청에서 사용되는 경우가 있기 때문에 계층의 분리가 필요하다

🌼 영속 계층

• 저장되어 있는 데이터를 꺼내오는 작업을 구현하는 계층
• 하나의 비즈니스 로직이 데이터에 여러번 접근해야 하는 경우와 하나의 데이터가 여러 비즈니스로직에 사용되는 경우가 있기 때문에 계층의 분리가 필요하다

🍀 스프링 웹 프로젝트에서 각 계층에 대한 클래스 이름 규칙

• 비즈니스 로직: xxxService(인터페이스), xxxServiceImpl(인터페이스 구현)
• 영속 계층 : xxxMapper(Mybatis), xxxDao, xxxRepository(저장소, DB에 데이터를 저장하거나 꺼내는 역할을 하는 클래스들)
• 데이터 클래스 : xxxVO(Getter만 붙은 읽기 전용(느낌) xxxDTO(Getter/Setter 보유)

🍀 웹 프로젝트에서 패키지를 나누는 방식

🌼 프로젝트 규모가 작은 경우

• 컨트롤러, 비즈니스 계층, 영속 계층, DTO를 구분할 수 있도록 패키지를 작성한다

  ex> com.company.bookstore.controller.BookListController
   com.company.bookstore.controller.PurchaseController
   com.company.bookstore.service.BookListService
   com.company.bookstore.service.PurchaseService
   com.company.bookstore.mapper.BookListMapper
   com.company.bookstore.dto.BookDTO

🌼 프로젝트 규모가 큰 경우

• 우선 비즈니스 단위별로 패키지 구분을 한 뒤 다시 내부에서 각 계층을 구분한다

  ``` ex> com.company.bookstore.booklist.controller.IndexController com.company.bookstore.booklist.controller.BookDetailController com.company.bookstore.booklist.service.IndexService com.company.bookstore.membership.controller.RegisterController com.company.bookstore.membership.controller.MypageController

• JDBC에서 발생하는 작업들을 로그로 찍어주는 라이브러리
• 디버깅이 매우 수월해진다

🌼 적용순서

1. pom.xml에 등록

• log4jdbc에서 Maven을 복사해도 됨
• 아래 내용을 복봍해도 됨

<dependency>

<groupId>org.bgee.log4jdbc-log4j2</groupId>
<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
<version>1.16</version>

2. root-context에 jdbcUrl, driverClassName 변경

<property name="driverClassName" value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy"/>
<property name="jdbcUrl" value="jdbc:log4jdbc:oracle:thin:@localhost:1521:XE"/>

### 3. resources에 log4jdbc.log4j2.properties 파일 추가
>```
파일명 : log4jdbc.log4j2.properties
파일내용 : log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

4. log4j.xml에 logger 추가

• jdbc.sqlonly : 실행하는 SQL문을 출력한다
• jdbc.sqltiming : 실행하는 SQL문과 실행하는데 걸린 시간을 출력한다
• jdbc.audit : ResultSet을 제외한 모든 JDBC 실행 과정을 출력한다
• jdbc.resultset : 모든 ResultSet의 실행 과정을 출력한다
• jdbc.resultsettable : 쿼리 실행 결과를 표로 출력해준다, 로깅 레벨을 debug로 설정하면 읽히지 않았던 값들도 모두 출력해준다
• jdbc.connection : jdbc connetion을 생성하고 닫는 과정을 출력한다, 메모리 누수(close를 하지 않아서 발생하는 문제)를 해결할 때 사용한다

🚀 log4jdbc 공식 페이지로 바로가기

• 쿼리문만 적으면 알아서 DB에서 데이터를 꺼내오는 프레임워크
• 거의 모든 jdbc관련 코드를 자동으로 생성해준다
• 개발자는 사용할 쿼리문과 종류만 선택하면 된다

🌼 필요한 의존성들

• mybatis
• mybatis-spring
• spring-jdbc

🌼 의존성 주입하기

• mybatis

• mybatis_spring

• spring_jdbc (스프링과 같은 버전 가져오기)

• 위 링크에서 Maven을 복사하여 pom.xml에 붙여 넣기

🌼 적용 순서

1. DBCP로 DataSource 객체를 생성한다 (HikariDataSource)

2. 생성한 DataSource 객체를 전달해 SqlSessionFactoryBean 객체를 생성한다 (컨텍스트 상에 생성한 sqlSessionFactory가 있으면 mybatis가 알아서 필요할 때 가져다 사용한다)

    <bean id="hikariDataSource" class="com.zaxxer.hikari.HikariDataSource">
        <constructor-arg ref="hikariConfig"></constructor-arg>
    </bean>

3. root-context의 Namespace에서 mybatis 체크(여기서 체크하면 임포트하는것과 같은 효과가 있다, 직접 임포트해도되고 여기서 체크해도됨)

4. mybatis-spring:scan 기능을 통해 패키지의 위치를 지정한다

    <mybatis-spring:scan base-package="com.ezen.springdatabase.mapper"/>

🍀 Mapper

• Mybatis에 Mapper 인터페이스를 등록하면 해당 Mapper의 정보를 통해 자동으로 메서드를 생성해준다 (내가 설정해야하는 것 : 리턴 타입, 쿼리문, 쿼리문 타입)
• 어노테이션 방식의 Mapper와 XML방식의 Mapper가 있다

🌼 어노테이션 방식 Mapper

🌱 어노테이션 종류

• @Select(query)
• @Insert(query)
• @Delete(query)
• @Update(query)

🌱 사용방법

• @Select로 조회하는 데이터가 여러 행인경우 List 타입으로 리턴해준다
• @Select로 조회하는 데이터가 한 행인 경우 해당 DTO 타입으로 리턴해준다
• 쿼리문에 파라미터가 필요한 경우 #{name}로 사용하고 @Param("name")으로 지정해준다
• @Insert, @Update, @Delete는 업데이트 된 행을 리턴하므로 정수 타입으로 리턴해준다
• @Insert, @Update시에 파라미터를 자바빈 데이터 클래스 형식(DTO)으로 넘기면 파라미터에 #{property}를 사용할 수 있다

🍀 XML 방식 Mapper

🌼 사용방법

1. Mapper Interface를 생성한다(메서드만 정의하고 어노테이션은 사용하지 않는다)
2. resources 밑에 해당 Mapper가 속한 패키지의 경로대로 폴더를 생성한다(폴더를 하나씩 생성하는 것이 좋다)
3. 해당 폴더에 같은 이름의 Mapper.xml을 생성한다
4. xml의 형식은 mybatis의 공식 페이지를 참조한다

🚀 mybatis_공식페이지 바로가기

• 프로그램을 효율적으로 개발하기 위해서 각 코드를 3가지로 구분하여 개발을 진행하고자 하는 디자인 패턴
• 프로그램의 비즈니스 로직과 화면을 구분하는데에 초점을 맞춘 디자인 패턴
• Model, View, Controller 세 가지로 나뉜다
• Model : 데이터의 형태를 표현하기 위한 용도의 코드
• View : 사용자에게 보여지는 화면을 꾸미기 위한 용도의 코드(Swing, html, css, js, jsp, ...)
• Controller : 요청을 받으면 어떤 서비스를 거쳐(비즈니스로직) 어떤 뷰로 가야할지를 결정하는 코드

🍀 @Controller

• 해당 클래스가 MVC패턴 중 Controller임을 표시하는 어노테이션
• spring-context가 자동으로 수거해 알아서 사용한다
• 어떤 요청 uri + method로 어떤 처리를 하고 어떤 뷰로 가야하는지를 정의하는 곳이다
• 다른 uri에서 같은 처리를 진행할 수도 있으므로 컨트롤러에서 비즈니스 로직을 구현하는 것은 바람직하지 않다

🌼 컨트롤러에서 자동으로 받을 수 있는 인자값들

1. HttpServletRequest

• 컨트롤러에서 JSP의 request객체를 받아서 사용할 수 있다

2. HttpServletResoponse

• 컨트롤러에서 JSP의 response 객체를 받아서 사용할 수 있다

3. 자바빈 형태의 모델 객체

• 파라미터의 이름과 모델 객체의 필드명이 동일하다면 값을 바인딩해준다
• 심지어, 데이터 타입도 알아서 변환해준다 (파라미터는 원래 String이였지만 age를 Integer로 변환하여 넣어준다)
• 만약 바인딩이 성공했다면 view에서 사용할 수 있도록 자동으로 어트리뷰트에 추가해준다

4. 전달받는 파라미터의 name과 같은 이름의 변수

• 파라미터와 같은 이름의 매개변수를 선언해두면 값이 알아서 바인딩된다
• 타입도 알아서 변환해준다
• 기본적으로 어트리뷰트에 자동으로 추가되지는 않는다
• 매개변수 앞에 @ModelAttribute("name")를 사용하는 경우 어트리뷰트에도 추가된다

5. HttpSession

• 세션 객체를 꺼내 활용할 수 있다

6. Model

• 어트리뷰트와 같은 역할

🌼 컨트롤러의 리턴 타입

** 1. 다음 view 페이지를 찾는 타입 **

• *String *
  • 리턴하는 문자열의 앞에 /WEB-INF/views/를 더하고 뒤에는 .jsp를 더해 다음 view페이지를 찾아 포워드한다
    • 리턴하는 문자열 앞에 redirect:를 붙이면 리다이렉트를 응답한다
• *void *
  • 컨트롤러로 접속할 때 사용했던 URI를 그대로 사용해 다음 view를 찾는다
• *ModelAndView *
  • 모델과 뷰를 모두 한번에 설정할 수 있는 객체

** 2. view를 찾지 않는 타입**

• 자바빈 객체 타입으로 리턴
  • 웹 페이지 코드 대신 데이터를 바로 응답한다
• ResponseEntity 직접 원하는 응답을 생성하여 응답한다 (직접 커스텀)

• 간단한 어노테이션 추가로 자바빈 스타일의 객체를 자동으로 완성해주는 라이브러리

🌼 Lombok 설치하기

1. 롬복 다운로드에서 다운로드 후 실행
2. sts.exe의 경로를 찾아서 지정(IDE 설정하기)
3. sts 재시작
4. maven repository에서 같은 버전의 maven을 복사
5. pom.xml의 dependencies에 붙여넣기
6. 프로젝트 우클릭 -> maven -> update project ... 실행
7. Package Explorer의 Maven Dependencies에서 해당 버전의 lombok이 잘 설치되었는지 확인

🌼 Lombok의 어노테이션들

• @Getter

  • 클래스 위에 붙이면 해당 클래스의 모든 필드에 대한 Getter를 생성한다
  • 필드 위에 붙이면 해당 필드에만 Getter를 생성한다

• @Setter

  • 클래스 위에 붙이면 해당 클래스의 모든 필드에 대한 Setter를 생성한다
  • 필드 위에 붙이면 해당 필드에만 Setter를 생성한다

• @ToString

  • 해당 클래스의 toString()을 알아서 적당히 구현해준다

• @NoArgsConstructor

  • 기본 생성자를 생성한다

• @AllArgsConstructor

  • 모든 필드값을 초기화해야 하는 생성자를 생성한다

• @RequiredArgsConstructor

  • 필수로 채워야하는 필드만 초기화하는 생성자를 생성한다
  • @NonNull이 붙어있는 필드를 필수로 채워야 하는 필드로 간주한다

• @EqualsAndHashCode

  • 해당 클래스의 equals()와 hashCode()를 적절하게 오버라이딩 한다
  • equals()는 모든 필드의 값이 일치하면 같은 객체로 인정한다
  • hashCode()는 모든 필드의 값이 일치하면 같은 값을 생성한다

• @Data

  • @Getter
  • @Setter
  • @ToString
  • @EqualsAndHashCode
  • @RequiredArgsConstructor를 모두 합친 어노테이션
  • 자주 쓰는 조합 .. ?

🌼 Lombok 사용하기

@Data
public class EmployeeDTO {
    String first_name;
    String last_name;
    Date hire_date;
    Integer salary;
}

1. 클래스 생성 후 멤버변수를 추가한다
2. 클래스에 @Data 어노테이션을 추가한다
3. Lombok이 Getter, Setter, 생성자, toString등을 모두 자동으로 생성해준다

• 로그를 효율적으로 남길 수 있는 기능들이 구현되어있는 라이브러리
• 각 로그마다 등급을 설정하고 일정 등급 이상의 로그만 보이도록 설정할 수 있다
• 프로젝트 폴더의 src/main/resources -> log4j.xml 내용을 확인할 수 있다(직접 수정도 가능)

🍀 Logger

• 각 클래스에 장착하면 해당 클래스에서 발생하는 로그를 수집하는 객체
• 발생하는 로그들을 등급별로 수집하여 Appender로 전송하는 역할을 한다
• 어떤 클래스를 감시해야하는지 클래스의 이름을 전달한다(클래스이름.class)

🍀 Appender

• 수집된 로그들을 출력하는 장소
• 파일, 콘솔, DB, 웹 등으로 발생한 로그들을 출력할 수 있다

🌼 File을 Append 하는 방법

• log4j.xml에 appender와 appender-ref를 추가

  <!-- Appenders -->
  <appender name="myfile" class="org.apache.log4j.FileAppender">
        <param name="file" value="/log/mylog.txt"/>
        <layout class="org.apache.log4j.PatternLayout">    
            <param name="ConversionPattern" value="%-5p: %c - %m[%d{HH:mm:ss}]%n" />
        </layout>
    </appender>
    <appender name="myfile2" class="org.apache.log4j.FileAppender">
        <param name="file" value="/log/mylog2.html"/>
        <layout class="org.apache.log4j.HTMLLayout"/>    
    </appender>
  
  <!-- Root Logger -->
    <root>
        <priority value="warn" />
        <appender-ref ref="console" />
        <appender-ref ref="myfile" />
        <appender-ref ref="myfile2" />
    </root>

• • 실행 결과 >> ** param의 value에 설정한 경로에 해당 로그 파일이 추가된다

🍀 Layout

• 로그를 출력하는 모양을 설정할 수 있다
• Log
• layout class의 param value에서 출력되는 형태를 직접 설정할 수 있다
• 설정한 모양대로 콘솔에 출력된다

🌼 Log4j 업데이트하기

1. Log4j에서 Maven 복사
2. pom.xml에서 log4j를 해당 내용으로 변경 후 저장
3. Package Explorer의 Maven Dependencies에서 log4j가 선택한 버전으로 변경되었는지 확인

🌼 Loging level

• OFF : 모든 등급의 로그를 끔
• FATAL : 아주 심각한 로그를 작성할 때 사용하는 등급(FATAL만 출력됨)
• ERROR : 에러 발생 로그를 작성할 때 사용되는 등급 (ERROR보다 심각한 로그만 출력됨 / 빨간줄 등급)
• WARN : 경고 로그를 작성할 때 사용하는 등급 (WARN보다 심각한 로그만 출력됨 / 노란줄등급)
• INFO : 일반적인 정보 로그를 작성할 때 사용하는 등급 (INFO보다 심각한 로그만 출력됨/운영단계)
• DEBUG : 디버깅 용도로 로그를 작성할 때 사용하는 등급 (DEBUG보다 심각한 로그만 출력됨/개발단계)
• TRACE : 에러를 추적하기 위한 정밀한 로그를 작성할 때 사용하는 등급 (모든 로그가 출력됨/개발단계)
• ALL : 모든 로그를 출력함(TRACE와 같다)
• 로깅 레벨은 log4j.xml에서 각 로거의 레벨(value)에서 설정할 수 있다

• 외부에서 두 객체간의 관계를 결정해주는 디자인 패턴
• 인터페이스를 사이에 두어 클래스 레벨에서는 의존관계가 고정되지 않도록 하고 런타임시에 관계를 동적으로 주입하여 유연성을 확보하고 결합도를 낮출 수 있도록 한다
• 유지보수성이 좋아진다는 장점이 있다

🌼 스프링이 자동으로 컨텍스트에 등록하는 어노테이션들

• @Component : 컨텍스트 로드시에 스프링이 자동으로 수거해가는 대상이 된다, 컴포넌트 스캔을 통해 특정 패키지의 컴포넌트들을 수거할 수 있다
• @Controller : MVC패턴에서 컨트롤러 역할을 하는 컴포넌트들을 표시해놓는 어노테이션
• @Repository : MVC패턴에서 모델 역할을 하는 컴포넌트들을 표시해놓는 어노테이션
• @Service : MVC패턴에서 비즈니스 로직을 수행하는 컴포넌트들을 표시해놓는 어노테이션

🌼 @Autowired를 통한 의존성 주입

• @Autowired가 적용되어 있는 자원은 컨텍스트 영역에 등록된 컴포넌트들 중 알맞은 컴포넌트를 자동으로 찾아 인스턴스를 주입해준다
• 생성자를 사용하지 않아도 스프링이 대신 인스턴스를 생성하여 주입해주기 때문에 클래스 간의 결합도가 낮아져 유지보수성이 올라가는 효과가 있다

🌼 Java Bean Object(자바빈 객체)

• 데이터 클래스를 만들 때 자주 사용하던 클래스의 형태를 자바빈 객체라고 한다
• 필드값(속성)의 접근 제어자는 private이어야 한다 (protected도 됨)
• 필드값에 대한 접근은 Getter/Setter를 통해 이루어져야 한다
• 기본 생성자가 반드시 존재해야 한다(다른 생성자를 쓰고 싶다면 기본 생성자를 반드시 명시해줘야 한다)
• 자바빈 스타일의 객체는 다양한 프레임워크, API, 라이브러리 등에서 기본 형태로 생각하기 때문에 반드시 지켜야한다

🌼 의존성 주입 방법

1. 자바빈 객체 생성 ** ✔ Student.java >> **

import org.springframework.stereotype.Component;
@Component
public class Student {
    private String name;
    private String grade;
    public Student(){
        name = "기본 이름";
        grade = "기본 등급";    
    }
    public Student(String name, String grade) {
        this.name = name;
        this.grade = grade;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGrade() {
        return grade;
    }
    public void setGrade(String grade) {
        this.grade = grade;
    }
    @Override
    public String toString() {
        return String.format("%s[%s]", name, grade);
    }
}

** 2. 컨트롤러에 Autowired 어노테이션 추가** ** ✔ HomeController.java >> **

@Controller
public class HomeController {
    private static final Logger logger = LoggerFactory.getLogger(HomeController.class);

    @Autowired
    Student student;

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String home(Locale locale, Model model) {

        System.out.println("stu : " + student);
        return "home";
    }
}

** 📺 출력 결과 >> **

-> Student를 직접 생성하지 않아도 Autowired으로 자동으로 생성됨을 확인할 수 있다

🍀 컨텍스트에 빈(Bean) 등록하기

• <bean>을 사용해 직접 등록하거나 컴포넌트 스캔을 통해 등록할 수 있다
• 컨텍스트에 등록된 자바 객체를 빈(bean)이라고 부른다
• 컨텍스트에 등록된 객체들은 알아서 적재적소에 사용된다
• 컨텍스트에 등록되는 객체들은 싱글톤 패턴으로 등록된다

🌼 servlet-context의 Bean Graph

• 내가 생성한 클래스들이 Bean으로 자동 등록된다

• 자바의 단위테스트용 라이브러리
• 스프링 프로젝트 배포시 작성되어있는 모든 단위 테스트를 통과해야 배포를 진행할 수 있다
• 기본 버전은 너무 옛날 것이므로 pom.xml에서 버던을 수정한 후 사용

🌼 JUnit 버전 업데이트 하기

1. JUnit 버전 업데이트 클릭 후 Maven에 있는 값 복사
2. pom.xml의 dependendy에서 junit찾기
3. 해당 부분에 복사한 내용 붙여넣기

🌼 JUnit의 어노테이션들

• @Test : 해당 메서드가 단위 테스트임을 표시하는 어노테이션
• @Ignore : 해당 테스트를 무시한다
• @Before : 테스트 시작 전 실행하는 메서드, 테스트 전에 초기화등의 작업을 먼저 수행하는 역할을 한다
• @After : 테스트 종료 후 실행하는 메서드, close()등의 작업을 수행할 때 사용한다

🌼 JUnit Asserts

• 기대하던 결과가 나오면 테스트를 통과하고, 기대하던 값과 결과가 다르면 테스트에 실패한다
• assertEquals(expect, test) : 기대하던 값과 결과가 일치하면 테스트 통과
• assertTrue(test) : 결과가 true면 테스트 통과
• assertFalse(test) : 결과가 false면 테스트 통과
• assertNull(test) : 결과가 null이면 테스트 통과
• assertNotNull(test) : 결과가 null이 아니면 테스트 통과
• assertThrows(expect, test) : 실행 도중 원하는 예외가 발생하면 테스트 통과
• fail() : fail()을 만나면 테스트 실패 (테스트 내부에서 return 같은 역할을 한다)

싱글톤(Singleton) 패턴

• 객체 내에서 단 하나의 인스턴스만 가지고 있는 것이 보장되는 디자인 패턴
• 주로 프로그램 내에서 하나로 공유를 해야하는 객체가 존재할 때 해당 객체를 싱글톤으로 구현하여 모든 유저 또는 프로그램들이 해당 객체를 공유하며 사용하도록 할때 사용한다

🍀 단위 테스트 (Unit test)

• 어떤 기능을 구현한 후 해당 기능이 원하는 대로 동작하는지 보기 위해 작성하는 프로그램
• 테스트 중 가장 작은 단위의 테스트에 속한다
• 어떤 메서드를 실행했을 때 기대하는 값이 잘 나오는지 체크하는 방식으로 진행

🍀 TDD(Test Driven Development, 테스트 주도 개발)

• 조건을 만족하는 테스트 프로그램을 먼저 작성한 후 해당 테스트를 통과하는 기능을 구현하는 방식의 개발(테스트 케이스와 테스트 코드를 먼저 작성)
• 테스트 단위로 기능이 구현되기 때문에 더욱 객체지향적인 개발이 가능해진다
• 유지보수(리팩토링)이 용이해진다
• 익숙하지 않으면 시간이 너무 오래 걸리기 때문에 생산성이 저하된다 (생산 비용 증가)

🍀 Jnuit 단위테스트 방법

1. src/main/java 폴더에 패키지와 클래스를 만든다
2. 클래스 안에 만들고 싶은 기능을 작성한다
3. src/test/java 폴더에 같은 이름의 패키지를 만든 후 우클릭하여 JUnit Test Case 생성
4. test 메서드 안에 assertEquals(기대하는 값, 내가 생성한 클래스.메서드(매개값) 전달
5. 우클릭 -> Run As -> JUnit Test 실행

🌼 단위 테스트 실행

** ✔ MyStringBuilder.java **

package com.ezen.springmvc.common;

public class MyStringBuilder {
    public static String reverse(String str) {
        str = new StringBuilder(str).reverse().toString();
        return str;
    }
}

** ✔ MyTest.java **

package com.ezen.springmvc.common;
public class MyTest {
    @Test
    public void test1() {
        assertEquals("elppa", MyStringBuilder.reverse("apple")); // 다른 폴더에 있지만 같은 패키지이기 때문에 import가 필요없다
        // 기대하는 값을 쓰고 테스트 할 유닛을 전달
    }
}

** 📺 실행 결과 >> **

🍀 단위 테스트에서 Autowired 사용하기

• Autowired는 서버가 켜질 때 실행되기 때문에 서버를 통하지 않는 단위테스트에서는 사용이 불가하다
• 단위테스트에서 Autowired를 사용하기 위해서는 spring context와 spring testContext의 버전을 업데이트 해야한다

와 spring test context를 release버전으로 업데이트 하고 다음 내용을 추가 @RunWith(SpringRunner.class) @ContextConfiguration("file:src/main/webapp/WEB-INF/spring/appServlet/servlet-context.xml")

• 테스트 케이스에 테스트 할 클래스를 선언한 뒤 @Autowired를 붙이면 @Component 어노테이션을 붙인 유닛을 찾아서 알아서 실행해준다

🌼 pom.xml에서 스프링 프레임워크 버전 업데이트 하기

• spring context에서 Maven을 복사한 후 <dependencies>의 <dependency>에 붙여넣기
• spring context와 같은 버전의 spring test context를 복사하여 <dependencies>에 추가
• <properties>의 <java-version>을 1.8로 변경 후 <configuration>의 <source>와 <target>을 앞에서 설정한 변수명(${java-version}으로 변경)
• 해당 프로젝트 우클릭 -> Maven -> Update Project ... 실행

** MyReducer.java (인터페이스) **

@RunWith(SpringRunner.class)
@ContextConfiguration("file:src/main/webapp/WEB-INF/spring/appServlet/servlet-context.xml")

** MyReducer_Impl.java (구현체) **

@Component
public class MyReducer_Impl implements MyReducer {
    @Override
    public Integer reduce(Integer[] arr) {
        int sum = 0;
        for(Integer i : arr) {
            sum += i == null ? 0 : 1;
        }
        return sum;
    }
}

** MyReducerTest.java (테스트케이스) **

@RunWith(SpringRunner.class)
@ContextConfiguration("file:src/main/webapp/WEB-INF/spring/appServlet/servlet-context.xml")
public class MyReducerTest {
    @Autowired
    MyReducer reducer;

    @Before
    public void test0() {
        System.out.println(reducer);
    }
    @Test
    public void test1() {
        assertEquals(Integer.valueOf(150), reducer.reduce(new Integer[] {10,20,30,40,50}));
    }
    @Test
    public void test2() {
        assertEquals(Integer.valueOf(120), reducer.reduce(new Integer[] {10,20,null,40,50}));
    }
    @Test
    public void test3() {
        assertEquals(Integer.valueOf(0), reducer.reduce(new Integer[] {null, null, null}));
    }
}

• Maven은 자바 프로젝트의 빌드(build)를 자동화 해주는 빌드 툴(build tool)
• 프로젝트를 진행하면서 필연적으로 발생하는 다양한 작업들을 편리하게 관리할 수 있는 빌드 자동화 도구 ex: 라이브러리 관리(JSTL 다운받고 등록하고 .. ) 라이브러리 버전 관리(다른버전으로 다시 다운받고 .. 다시 등록하고 .. ) 프로젝트 버전 관리(프로젝트 업데이트하면 이름 바꿔주고 .. 관리하고..) 프로젝트 배포 관리(프로젝트의 배포판 생성하기)
• 프로젝트 내부의 pom.xml을 통해 전체 프로젝트를 관리할 수 있는 프로그램이다

🌼 POM(Project Object Model)

• 프로젝트 객체 모델
• 해당 프로젝트에 대한 여러가지 설정 및 의존성등의 정보들을 담고 있다
• 프로젝트 전체에 대한 명세서

🌼 pom.xml

• <groupId> : 이 프로젝트의 그룹 아이디 (패키지 이름에 사용했던 회사 이름)
• <artifactId> : 이 프로젝트의 프로젝트명(패키지에서 쓸 이름)
• <name> : 이 프로젝트의 프로젝트 이름(대소문자 버전)
• <packaging> : 이 프로젝트의 빌드 결과가 무엇일지 설정
• <version> : 이 프로젝트의 현재 버전
• <properties> : pom.xml 내부에서 사용할 변수 등록
• <dependencies> : 이 프로젝트를 구성하는 데에 필요한 다른 프로젝트들(이 프로젝트가 의존하는 다른 프로젝트들)

               여기에 등록한 프로젝트들은 메이븐이 자동으로 다운로드하여 관리해준다
               프로젝트 빌드(BuildPath)에도 자동으로 포함시킨다

• <dependency> : 의존하는 프로젝트의 pom 정보를 적어 등록하는 곳

             해당 프로젝트의 <groupId>, <artifactId>, <version>등을 적어 이 프로젝트에 포함시킨다
             <scope>를 설정하여 이 프로젝트에서 어느정도 범위까지 필요한지 설정할 수 있다

🌼 <scope>의 종류

• compile : 프로젝트를 컴파일 할 때 필요한 의존성, 컴파일 당시에도 사용되고, 프로젝트 배포시에도 포함된다(기본값)
• runtime : 컴파일할 때는 필요 없지만 해당 프로젝트를 실행할 때는 필요한 의존성, 프로젝트 배포시에 포함된다
• provided : 컴파일 할 때는 필요하지만 실행할 때는 필요없는 의존성(JSP 등), 프로젝트 배포시에는 포함되지 않는다
• test : 테스트 단계에서만 필요한 의존성, 컴파일 및 배포에 모두 포함되지 않는다

🌼 Maven의 원격 레포지토리와 로컬 레포지토리

• Maven <dependencies>에 등록한 모든 프로젝트들을 중앙 원격 레포지토리에서 다운받는다
• 다운받은 프로젝트들은 user/.m2/repository/groupId/artifactId/...폴더에 버전별로 보관된다(로컬 레포지토리)

1. JDK11을 다운로드(충돌 방지) 후 설치 JDK11 다운로드
2. Spring 다운로드 후 설치 spring 다운로드
3. spring-workspace 폴더 만들어 workspace폴더 지정
4. 기본 설치된 서버 지우고 apache tomcat으로 재설정
5. 프로그램 종료 후 스프링 폴더의 STS.ini 파일에 아래 내용 추가 -vm C:\Program Files\Java\jdk-11\bin\javaw.exe(jvm경로를 넣는다)
6. window -> preference에서 encoding 검색 후 모든 인코딩 설정을 'UTF-8'로 변경
7. File -> new -> SpringLagacyProject 선택
8. SpringMVCProject 선택 후 next화면에서 아래처럼 com.mycompany.myapp 형태로 작성
9. 프로젝트 폴더에 빨간 엑스 나올 때 : 프로젝트 우클릭 -> Maven -> update project 실행

🍀 스프링 프레임워크

• 자바를 이용해 웹 애플리케이션 서버 개발을 효율적으로 진행하기 위한 프레임워크
• 다양한 디자인 패턴 및 기능들이 미리 구현되어 있기 때문에 효율적으로 개발을 진행할 수 있다

🌼 프레임워크(Framework)

• 프로젝트 개발에 효율적인 구조를 미리 만들어 놓은 것(PPT 템플릿 같은 것)
• 개발자는 이미 완성된 구조에 빈칸을 채우는 느낌으로 프로젝트를 진행할 수 있다
• 전체적인 구조(디자인 패턴 등)에 대한 지식이 없는 초보 개발자들도 프로젝트에 투입할 수 있다는 장점이 있다
• 일정 수준 이상의 품질이 항상 보장된다
• 개발 비용이 많이 절감된다

🌼 스프링의 특징

1. POJO (Plain Old Java Object)

• JSP처럼 새로운 공부가 필요한 문법들의 사용을 지양한다
• 백엔드에 JSP 코드가 섞이는 것은 바람직하지 않으며 순수 JAVA코드로 작성되어야 한다
• 익숙치 않은 별도의 API를 최대한 배제하여 개발자의 혼란을 최소화 한다

2. 제어의 역전(IoC, Inversion of Controll)

• 개발자가 객체를 생성하는 것이 아니라 스프링이 객체를 만들고 메서드를 호출한다
• 객체의 생성과 관리를 개발자가 하는 것이 아니라 스프링 프레임워크가 대신한다

3. 의존성 주입(DI, Dependency Injection)

• 외부에서 객체를 주입받아 사용하는 것
• 생성자를 아예 사용하지 말자 (생성자로 인해 유지보수 비용이 증가)
• 프로젝트 내부의 생성자 사용을 모두 제거하여 객체간의 결합도를 낮출 수 있다

※ 결합도가 높다 -> 하나 수정하면 빨간 줄이 100개 뜬다 ※ 결합도가 낮다 -> 객체 하나 수정해도 거의 문제가 안생긴다

🌼 스프링 프로젝트의 기본 구조

• src/main/java : 자바 코드를 작성하는 곳
• src/main/resources : 자바 코드를 실행할 때 필요한 자원들을 저장하는 곳
• src/test/java : 작성한 자바 코드에 대한 테스트 코드를 작성하는 곳
• src/test/resources : 테스트 코드를 실행할 때 필요한 자원들을 저장하는 곳
• Maven Dependencies : 이 프로젝트가 의존하고 있는 다른 프로젝트들 목록
• webapp/resources : 웹 정적 자원들을 보관하는 곳
• webapp/WEB-INF/spring/appServlet/servlet-context.xml : appServlet(디스패처 서블릿)의 초기화 파라미터들을 정의하는 곳(지역 초기화 파라미터, ServletConfig)
• webapp/WEB-INF/spring/root-context.xml : 전역 초기화 파라미터들을 정의하는 곳(전체 초기화 파라미터, ServletContext)
• webapp/WEB-INF/views : 뷰 페이지(.jsp)들을 보관하는 곳
• webapp/WEB-INF/web.xml : 서버 설정 파일
• pom.xml : 메이븐 프로잭트에서 사용하는 설정 파일

🍀 스프링 인코딩설정

• web.xml에 다음 내용을 추가 후 서버 재시작

  <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
        <!-- 설정된 인코딩이 있더라도 내가 등록한 것으로 강제로 인코딩 하게 설정 -->
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <servlet-name>appServlet</servlet-name>
    </filter-mapping>

** ✔ index.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:url value="/resources/js/popup/index.js" var="js1"/>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>팝업창 열기</title>
</head>
<body>
    <input id="addr" type="text" />
    <button id="btn1">팝업 열기</button>

<!-- c:url에서 설정한 var 값을 주면됨 -->
    <script src="${js1}"></script>

</body>
</html>

** ✔ popup.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>버튼을 누르면 새창에서 열리는 팝업창입니다</title>
</head>
<body>
    새 창에서 열릴 내용입니다 ... <br>
    <br>
    이 팝업창을 연 부모창은 opener라는 객체로 접근할 수 있다. <br>
    <script src="<%=request.getContextPath() %>/resources/js/popup/popup.js"></script>
</body>
</html>

** ✔ index.js >> **

const btn1 = document.getElementById('btn1');
btn1.addEventListener('click',(e)=> {
    window.open('./popup.jsp','_blank',
    'width=500, height=500, top=100, left=100'); // 새 창을 열어주는 자바스크립트 함수
});

** ✔ popup.js >> **

//opener : 이 창을 연 부모 객체 window
console.log(opener);
console.log(opener.document.getElementById('addr'));
opener.document.getElementById('addr').value='apple';
opener.document.body.style.backgroundColor='green';

** 📺 화면 출력 >> **

팝업열기 버튼을 눌렀을 때 >> 팝업 >>

index.jsp 화면 >>

팝업 옵션 참고

• key와 value로 된 값
• 서버에서 생성한 쿠키를 응답에 실어보내면 클라이언트의 웹 브라우저에 보관한다
• 웹 브라우저는 해당 서버로 요청을 보낼 때 마다 보관하고 있던 쿠키를 요청에 함께 실어 전달한다
• 쿠키에 저장되는 값은** 클라이언트 측에서 언제든지 위/변조가 가능하다는 것**을 감안하고 사용해야 한다(보안이 없다)
• 쿠키는 서버에서 클라이언트의 웹 브라우저에 name/value를 추가하는 것이고 로컬/세션 스토리지는 클라이언트 측의 자바스크립트에서 추가된다는 차이가 있다

🏁 Cookie의 설정값들

🤺 maxAge

• 쿠키의 수명을 설정할 수 있다 (초 단위)
• 기본값은 -1이 된다
• 0은 삭제 / -1은 세션을 의미한다

🤺 path

• 쿠키가 어떤 URI 범위에서 사용될지를 설정할 수 있다
• 기본값은 현재 경로가 된다

🏁 쿠키 추가/삭제하기

※ 어떤 쿠키의 값 또는 수명을 수정하려고 할 때 name 뿐만 아니라 path까지 정확하게 일치해야 해당 쿠키를 수정할 수 있다

🤺 쿠키 추가하기

** ✔ list.jsp >> **

<%
    // 모든 요청은 클라이언트에 보관된 쿠키를 함께 가져온다
    Cookie[] cookies = request.getCookies();
    for(Cookie cookie : cookies){
        System.out.println(cookie.getName()+ " = " + cookie.getValue());
    }
%>

** 📺 화면 출력(콘솔) >> **

🤺 쿠키 삭제하기

** ✔ list.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>    
<%
    // 모든 요청은 클라이언트에 보관된 쿠키를 함께 가져온다
    Cookie[] cookies = request.getCookies();
    // EL / JSTL의 반복문을 활용하기 위해 어트리뷰트에 등록
    pageContext.setAttribute("cookies", cookies);
    for(Cookie cookie : cookies){
        System.out.println(cookie.getName()+ " = " + cookie.getValue());
    }
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Cookie List</title>
</head>
<body>
    <div style="display:grid; grid-template-columns:1fr 100px;">
    <!-- c:forEach는 Getter가 달린 Object 라면 무조건 활용할 수 있다는 장점이 있다 -->
        <c:forEach items="${cookies }" var="cook">
            <div>
            ${cook.name }=${cook.value} 
            </div>
            <div>
            <a href="./delete.jsp?name=${cook.name }">[삭제]</a>
            </div>
        </c:forEach>
    </div>
</body>
</html>

** ✔ delete.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<% 
    String cookie_name = request.getParameter("name");
    // 쿠키의 수명을 0으로 변경하면 쿠키가 삭제된다
    // 쿠키는 하나만 꺼내는 메서드가 존재하지 않아서 번거롭다
    Cookie[] cookies = request.getCookies();
    if(cookies != null){
        for(Cookie cookie : cookies){
            if(cookie.getName().equals(cookie_name)){
                cookie.setMaxAge(0); //쿠키의 수명을 0으로 변경하여 삭제 
                response.addCookie(cookie);
            }
        }
    }
    response.sendRedirect("./list.jsp");
%>

• 포워드처럼 request와 response를 다른 jsp로 보냈다가 다시 돌아오는 기능
• 다른 페이지로 잠깐 갔다 돌아오는 기능이기 때문에 page scope의 값을 사용할 수는 없다

🏁 File include

• 해당 파일 내용을 읽어서 현재 jsp 내부에 포함시키는 기능
• 컴파일 이전에 파일 내용을 포함시킨 후 컴파일을 진행하게 된다
• page scope의 값을 사용할 수 있다

🤺 JSP include 사용해보기

** ✔ main.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!-- 여기는...Servlet extends HttpServlet 이 생략되어 있음 -->    
<jsp:include page="/include/top.jsp"></jsp:include> 
<h1>제목</h1>
<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit.
 Quod ullam placeat cum pariatur at nulla eum iure neque rerum 
 corrupti veritatis fuga doloremque esse explicabo ut quia aspernatur numquam enim.
 Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptatum dignissimos 
 molestias aspernatur voluptatem iure officia cumque fugit neque sint excepturi ut 
 eaque facilis rem illo at nostrum qui odit ab!</p>
 <!-- contextpath는 생략 가능 / webapp 아래의 경로를 줘야함 -->
 <jsp:include page="/include/bottom.jsp"></jsp:include>

** ✔ top.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Top.jsp에서 정한 제목</title>
</head>
<body>
<table border="1">
    <tr>
        <th>메뉴소개</th>
        <th>찾아오시는 길</th>
        <th>체인점</th>
        <th>사이트맵</th>
        <th>고객센터</th>
    </tr>
    <tr>
        <th>
            <ul>
                <li>Side menu1</li>
                <li>Side menu2</li>
                <li>Side menu3</li>
                <li>Side menu4</li>
                <li>Side menu5</li>
            </ul>        
        </th>
        <td colspan="4">
<!-- 여기는 top.jsp이기 때문에 이하는 지워도된다 -->

** ✔ bottom.jsp >> **

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
        </td>
    </tr>
    <tr>
        <th colspan="5">
            전화번호 : 123-1234-1234 | 사업자등록번호 : 123-123-123
            | FAX : 1234-123-1234 ...
        </th>
    </tr>
</table>
</body>
</html>

** 📺 main.jsp 실행 결과 >> **

• 특정 주소로 접속할 때 이 필터를 거쳐서 지나가도록 만들 수 있다
• web.xml에서 필터 등록을 한 후 특정 URL에 대한 매핑을 해놓을 수 있다
• chain으로 다음 필터를 호출하면
• javax.servlet.Filter를 import 해야한다

🤺 Filter 구현하기

public class MyFilter1 implements Filter {
    @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            // 필터를 초기화하는 곳
        }    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 필터 기능 수행 ... 
        chain.doFilter(request, response);// chain으로 다음 필터로 쿼리 전달
    }    
}

• doFilter 메서드는 요청이 있을 때 마다 매번 실행된다 참고

🤺 Filter 설정하기

• web.xml에서 모든 경로로 들어오는 요청에 대해(*/) 인코딩필터를 지나가도록 설정한다
• 인코딩 필터를 지나가는 모든 request는 characterEncoding을 EUC-KR로 세팅하도록 설정한다

** ✔ web.xml >> **

  <filter>
      <filter-name>characterEncodingFilter</filter-name>
      <filter-class>chap10.filter.CharacterEncodingFilter</filter-class>
  </filter>

  <filter-mapping>
      <filter-name>characterEncodingFilter</filter-name>
    <!-- 모든 요청에 대해 인코딩을 수행 -->
      <servlet-name>/*</servlet-name> 
  </filter-mapping>

** ✔ CharacterEncodingFilter.java >> **

public class CharacterEncodingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        System.out.println("인코딩 필터를 지나감");

        // 모든 요청에 대한 인코딩 처리를 미리 진행할 수 있다
        request.setCharacterEncoding("EUC-KR");
        response.setCharacterEncoding("EUC-KR");

        chain.doFilter(request, response);
    }
}

🏁 Listener

• 특정 이벤트(특정 사건)가 발생하기를 기다리다가 실행되는 컴포넌트(메서드나 함수)
• ContextLoaderListener : Context 내부의 내용에 뭔가 변화가 있는 경우 ReLoad할 때 호출되는 이벤트리스너

🤺 리스너 등록하기

** ✔ web.xml >> **

 <listener>
      <listener-class>chap10.listener.MyServletRequestProcess</listener-class>
 </listener>
 <listener>
      <listener-class>chap10.listener.ContextLoaderListener</listener-class>
  </listener>

** ✔ MyServletRequestProcess.java >> **

public class MyServletRequestProcess implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // 요청 초기화 시점
        //요청 시작 부분에 이벤트 처리 하고 싶은 내용을 적는다

        // sre 객체에 ServletRequest와 ServletContext가 모두 들어있다
        System.out.println("파라미터 : " + sre.getServletRequest().getParameter("flavor"));
        // 파라미터 꺼내서 찍어보기
    }    
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {        
        //요청 마무리 부분에 이벤트 처리 하고 싶은 내용을 적는다
    }
}

** ✔ ContextLoaderListener.java >> **

public class ContextLoaderListener implements ServletContextListener{
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ContextLoaderListener : 컨텍스트 내부에 뭔가 변화가 있습니다 ...");
        System.out.println("ContextLoaderListener : 다시 초기화합니다");
    }
        @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ContextLoaderListener : ServletContext Destroyed ... ");
    }
}

• HTTP 프로토콜로 들어오는 모든 요청을 가장 먼저 받아 적합한 컨트롤러에 위임해주는 프론트 컨트롤러(Front Controller)
• 쇼핑몰의 인포 데스크처럼 입구에서 기다리고 있다가 요청에 따라 길을 안내해주는 역할

🤺 DispatcherServlet 작성 순서

1. 디스패쳐 서블릿을 만들고 HttpServlet을 상속받고 init과 service를 오버라이드 해서 사용한다

** ✔ DispatcherServlet.java (예시) >> **

public class DispatcherServlet extends HttpServlet{
    private Map<String, RequestProcess> processMapping = new HashMap<>();

    @Override
    public void init(ServletConfig config) throws ServletException {
        // config에서 application scope를 꺼내 contextPath를 꺼냄
        String contextPath = config.getServletContext().getContextPath();
        // 어떤 주소 + 어떤 요청 방식으로 접속했을 때 어떤 처리를 할 것인지 등록
        processMapping.put(contextPath + "/hello::GET", new HelloProcess());
    }
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // 1. 사용자의 요청을 받는다
        System.out.println("사용자가 요청한 URL : " + request.getRequestURL());
        System.out.println("사용자가 요청한 URI : " + request.getRequestURI());
        System.out.println("요청 방식 : " + request.getMethod());

        try {
            // 2. 요청한 URI와 Method에 맞는 처리를 진행한다 (객체지향화)
            //         -> uri와 method로 알맞은 RequestProcess를 골라 process()를 실행시킨다
            String nextPage = processMapping.get(request.getRequestURI() + "::" + request.getMethod()).process(request, response);

            // 3. 처리 후 알맞은 view 페이지로 포워드 하거나 redirect한다
            if(nextPage.startsWith("redirect:")) {
                response.sendRedirect(nextPage.substring("redirect:".length()));
            }else {
            request.getRequestDispatcher("/WEB-INF/views" + nextPage + ".jsp").forward(request, response);
            }
        }catch(NullPointerException e) {
            response.getWriter().append("<html><script>history.back();</script></html>");
        }
    }
}

2. web.xml에서 servlet, servlet-mapping 작성

   <servlet>
      <servlet-name>appServlet</servlet-name>
      <servlet-class>servlet.DispatcherServlet</servlet-class>
   </servlet>
   <servlet-mapping>
   

appServlet /