🌊 ._.sori🪽

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   컬렉션 프레임워크_ 624p

• 컬렉션(collection)

: 동일한 타입을 묶어 관리하는 자료구조로 데이터의 저장 용량을 동적으로 관리할 수 있다.

• 프레임워크(framework)

: 설계의 원칙 또는 구조에 따라 클래스 또는 인터페이스를 설계하고, 설계된 클래스와 인터페이스를 묶어 놓은 개념이다.

• 컬렉션 프레임워크

: 리스트, 스택, 큐, 트리 등의 자료구조에 정렬, 탐색 등의 알고리즘을 구조화해 놓은 프레임워크

Q. 컬렉션과 배열의 차이점은?

A. 배열은 생성 시점에 저장 공간의 크기를 확정하며 확정한 후 변경할 수 없다. 반면에 컬렉션은 데이터의 개수에 따라 동적으로 저장공간이 달라진다.

Q. 프레임워크와 라이브러리의 차이점은?

A. 일반적으로 단순히 연관된 클래스와 인터페이스들의 묶음을 라이브러리라고 한다. 프레임워크와 라이브러리의 가장 큰 차이점은 애플리케이션의 흐름의 주도권을 누가 쥐고 있는지라고 생각한다. 프레임워크는 스스로 제어 흐름의 주도권을 잡으면, 라이브러리는 개발자가 주도권을 가지고 있다. 프레임워크는 큰 틀로 개발할 수 있는 범위와 따라야 할 가이드가 존재한다. 라이브러리는 특정 기능을 도와주는 도구와 같은 역할을 한다. 

✔️   List<E> 컬렉션 인터페이스_ 626p

• List<E>

: 인터페이스며 대표적인 클래스로 크게 ArrayList<E>, Vector<E>, LinkedList<E>가 있다.

List<Integer> aList1 = new ArrayList<Integer>();
ArrayList<Integer> aList2 = new ArrayList<Integer>(30);
Vector<String> aList3 = new Vector<String>();
List<MyWork> aList4 = new LinkedList<MyWord>();
List<MyWork> aList5 = new LinkedList<MyWord>(20); // 오류 발생!!

제네릭에 대해 배웠었다. 제네릭은 클래스 내부에서 사용할 데이터 타입을 외부에서 지정할 수 있도록 하는 기법으로, 꺾쇠 괄호< >안에 타입을 적는다. 객체를 생성할 때 지정한 타입과 다른 타입을 사용하면 컴파일 시점에 오류를 발생시켜, 타입 안정성을 보장해준다.

List<E> 자체는 제네릭 인터페이스로 이를 상속한 자식 클래스 모두 제네릭 클래스가 된다. 즉, 객체를 생성할 때 제네릭의 실제 타입을 지정해야 한다. <E>에서 E는 요소의 Element를 뜻하여 여기서 어떤 타입의 데이터를 지정할지 외부에서 지정한다. aList1은 Integer로 지정되었으니 정수만 저장할 수 있는 List가 되었다.

aList1은 부모 타입인 List<E>로 선언했고, aList3은 자식 클래스인 구체적인 구현 클래스 타입으로 선언했다. 이는 자바의 다형성을 활용한 것으로, 컬렉션 객체는 부모 타입(List)으로도 선언할 수 있고, 구체적인 자식 클래스(ArrayList, LinkedList 등)로도 선언할 수 있다.

LinkedList<E>를 제외한 나머지 대표 구현 클래스는 초기 저장 용량을 매개변수로 포함하고 있는 생성자를 만들 수 있다. 이때 저장 용량은 실제 데이터 개수를 나타내는 저장 공간의 크기와는 다른 개념으로, 데이터를 저장하기 위해 미리 할당해 놓은 메모리 크기라고 생각면 된다.

Q. 제네릭을 쓰지 않은 List는 어떻게 다를까?

A. 타입을 지정하지 않은 List로 Object 타입으로 간주되어 아무 타입이나 넣을 수 있다. 하지만 꺼낼 때 일일이 형변환이 필요하며 컴파일 시 오류를 잡을 수 없다는 단점을 지니고 있다.

List list = new ArrayList();
list.add("Hello");
list.add(123);​

• Arrays.asList( )

: 배열을 리스트로 변환하는 메서드, 내부적으로 배열을 먼저 생성한 후 List<E>로 래핑하기 때문에 저장 공간의 크기를 변경할 수 없다.

List<Integer> aList7  = Arrays.asList(1,2,3,4);
List<String> aList8  = Arrays.asList("안녕","하세요");

Arrays.asList( ) 정적 메서드는 내부 구조가 배열과 동일하여 데이터를 추가(add( ))하거나 삭제(remove( ))가 불가하다. 다만 저장 공간의 크기를 변경하지 않는 데이터의 변경(set( ))은 가능하다. 주로 고정된 개수의 데이터를 저장하거나 활용할 때 주로 사용한다.(예로 요일이 있다.)

• List<E>의 주요 메서드

✔️   ArrayList<E> 구현 클래스_ 632p

• ArrayList<E>

: List<E> 인터페이스를 구현한 구현 클래스로 수집한 원소를 인덱스로 관리하여 저장 용량을 동적으로 관리한다.

List<Integer> aList1 = new ArrayList<Integer>();
aList1.add(1);
aList1.add(2);
System.out.println(aList1.toString()); // aList1=[1,2]

aList1.addAll(1,aList1);
System.out.println(aList1.toString()); // aList1=[1,1,2,2]

aList1.set(1,5);
System.out.println(aList1.toString()); // aList1=[1,5,2,2]

aList1.remove(1);
System.out.println(aList1.toString()); // aList1=[1,2,2]

aList1.remove(new Integer(2));
System.out.println(aList1.toString()); // aList1=[1]

aList1.clear();
System.out.println(aList1.toString()); // aList1=[]

add는 값을 추가하고 addAll은 aList1 전체를 1번째에 추가한다는 의미이다. set의 경우 변경을 의미하는데, 인덱스 1번째 값을 5로 바꿨다. remove는 두가지로 나뉜다. remove(int index)로 인덱스 값을 찾아 삭제하는 것과 remove(Object o)로 값을 삭제하는 것. 그래서 aList1.remove(1)은 1번째 인덱스를 삭제했고, aList.remove(new Integer(2))는 숫자 2를 찾아 삭제했다. clear은 모든 원소를 삭제한다는 의미다. 

Q. remove에서 원소의 값을 삭제하고 싶을 때 new Integer(2)와 같이 쓰는데, 왜 new를 붙이는걸까?

A. 인덱스 값으로 삭제하는 방식과 혼동하지 않기 위해 객체를 생성하도록 한다.  alist.remove(new Integer(2))은 값이 2이 integer 객체를 찾아 삭제하라는 의미로 일련의 과정을 살펴보자. 첫번째로 new Integer(2)을 통해 값이 2인 Integer 객체를 하나 생성한다. 그 다음 remove(Object o)를 호출하면서 이 객체를 인자로 넘긴다. 리스트는 내부적으로 equals() 메서드를 사용해서 리스트 안에 있는 요소들과 이 객체2가 같은지 비교 후 같은 값이 있으면 삭제한다. Java 5부터 오토박싱(박싱과 언박싱을 자동적으로 처리)이 있어서 remove(Integer.valueOf(2))이나 remove((Integer)2)도 가능하기는 하나 new를 사용해서 삭제하는 것이 가장 안전하다.

List<Integer> aList2 = new ArrayList<Integer>();

System.out.println(aList2.isEmpty); // true

aList2.add(1);
aList2.add(2);
aList2.add(3);
System.out.println(aList2.toString()); // aList2 = [1,2,3]
System.out.println("size: " + aList2.size()); // size: 3
System.out.println("0번째: " + aList2.get(0))); // 0번째: 1

isEmpty( )는 데이터가 하나도 없을 때만 true값을 리턴한다. 주로 데이터의 존재 여부를 확인할 때 사용한다. size( )는 실제 데이터 개수를 리턴하며 추가와 삭제가 이뤄지면 그때마다 값은 변경될 것이다. get(int index)는 특정 위치의 값을 가져올 때 사용한다.

Q. 정수형을 담는 리스트인데 출력할 때 toString( )을 사용해야하는 이유는 무엇일까?

A. toString( ) 메서드를 사용하지 않아도 자동으로 호출되긴 하는데, 결국 내부적으로 toString을 사용하고 있다. toString을 사용하는 경우를 보면 문자열을 출력할 경우 혹은 객체를 출력하는 경우이다. 리스트에 담겨있는 것이 정수 타입이어도 리스트 자체를 객체로 분류하기 때문에 Object로서 toString( )을 호출한다.

✔️   Vector<E>, LinkedList<E> 구현 클래스_ 639p

• Vector<E>

: List<E> 공통적인 특성을 가지며, 동기화 메서드로 구현돼 멀티 쓰레드에 적합하다.

List<Integer> vector1 = new Vector<Integer>();

동기화메서드(synchronized method)로 구현된 Vector<E>는 하나의 공유 객체를 2개의 쓰레드가 동시에 사용할 수 없다. 하나의 쓰레드는 데이터를 읽고 또 하나의 쓰레드가 데이터를 삭제하는 작업을 동시에 수행해 작업이 충돌하는 상황을 방지한다. Vector<E>는 ArrayList<E>와 동일한 기능을 수행하지만, 멀티 쓰레드에서 사용할 수 있도록 기능을 추가했다. 만약 하나의 쓰레드만 사용하는 경우는 Vector<E>말고 ArrayList<E>를 사용하는 것이 더 적합하다.

• LinkedList<E>

: List<E> 공통적인 특성을 가지며, 앞뒤 객체의 정보를 저장하며 객체 생성시 저장 용량을 지정할 수 없다.

List<E> aLinkedList1 = new LinkedList<Integer>();

LinkedList<E>는 ArrayList<E>와 같이 동기화하지 않기 떄문에 싱글 쓰레드에 적합하다. ArrayList<E>와 다른 점은 저장 용량을 매개변수로 갖는 생성자가 없어 저장 용량을 지정할 수 없다는 것이다. 그리고 내부적으로 데이터를 저장하는 방식이 다른데, ArrayList<E>는 인덱스의 값으로 저장하지만 LinkedList<E>는 앞뒤 객체의 정보를 저장하여 모든 데이터가 서로 연결된 형태를 이룬다.

0번째에 새로운 원소 하나가 들어섰다. ArrayList<E>는 0번째 이후의 모든 원소들이 뒤로 밀려난다. 하지만 LinkedList<E>는 각 원소의 앞뒤 객체 정보만 가지고 오면 되므로 어딘가에 값이 추가되어도 앞뒤 정보만 수정하면 된다. 이런 것을 살펴보면 값이 추가되면 ArrayList<E>의 속도가 LinkedList<E>보다 느린 것을 알 수 있다. 대신 어떤 값을 찾아야하는 상황이라면, 인덱스 번호로 찾을 수 없으니 처음부터 하나하나 확인해야하는 LinkedList<E>가 훨씬 느릴 것이다.

강의 섹션 3에서 맨 처음 실행했을때는 잘 돌아가다가,
수업 진행에 따라 설정을 바꾸면서 갑자기 실행이 되지 않았다.
오류가 왜 발생했는지 찾아보고 해결을 해볼 것이다.

✦ 에러내용 :

Error starting ApplicationContext. To display the condition evaluation report re-run your application with 'debug' enabled.
2025-06-17T12:32:24.842+09:00 ERROR 46814 --- [servlet] [           main] o.s.boot.SpringApplication               : Application run failed

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'servletComponentRegisteringPostProcessor': Instantiation of supplied bean failed

✦ 원인 : 에러를 살펴보면 Spring이 servletComponentRegisteringPostProcessor라는 빈을 만들려고 했는데, 해당 빈의 인스턴스를 생성하지 못해서 실패했다고 써있다. 

✦ 이유 : IntelliJ 무료버전을 쓰면서 War 프로젝트를 만들었다. War란, Web ARchive로 보통 톰캣같은 서버에 배포해서 실행한다. 톰캣은 자바 웹 애플리케이션을 실행해주는 웹 서버로 War 파일을 넣으면 웹사이트로 작동하게 만들어준다. 즉 War 파일 프로젝트를 톰캣에 넣어 웹사이트가 실행되도록 하는 것이다. 이때 Tomcat은 내 프로젝트 안에 있지 않고 밖에 존재하도록 <scope>provided</scope> 코드를 사용하여 설정되어있다. 그런데 IntelliJ 무료버전은 외부 톰캣 서버를 직접 실행 할 수 없으니 문제가 발생한 것이다.

✦ 첫번째 해결 방법 : settings - gradle - Build and run using [Gradle]로 설정

김영한님의 수업을 듣다가 오류가 발생한 경우 IntelliJ IDEA로 변경해서 그런 것이다. 그래서 다시 Gradle로 바꿔주면 문제가 해결된다.

✦ 두번째 해결 방법 : Add dependencies with 'provided' scope to classpath

• Run 들어가기

• Edit Configurations 들어가기

• Modify options 들어가기

• Add dependencies with "provided" scope to classpath 누르기.

무료버전은 톰캣이 외부에 있다고 믿어 서버를 따로 지정해주지 않기 때문에 제대로 실행되지 않았다. 그 설정이 provided였는데, Add...classpath는 원래 실행할 때 포함되지 않아야 할 provided 라이브러리들을 강제로 classpath에 포함시켜 실행하길 원할때 체크하는 것이다.

✦ 세번째 해결 방법 : providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat' 주석처리하기.

• build.gradle에 들어가서 주석처리하기.

✦ 네번째 해결 방법 : 유료버전 구매하기.

SpringMVC에 본격적으로 들어가기전 기본적으로 알아야할 개념들을 섹션 2 강의에서 간단하게 설명했다. 강의를 들을 땐 개념에 대한 배경지식이 흐릿해서 수업을 듣고 있어도 수업의 흐름이 이해되질 않았다. 그래서 블로그에 WAS - 서블릿 - 서블릿 컨테이너 - 멀티쓰레드 - 쓰레드 풀이 어떤 식으로 연관을 갖는지를 중심으로 공부하고자 한다. 그리고 공부하면서 이해하는데 보충이 되는 개념과 설명이 있으면 함께 적고, 도중에 질문들이 생기면 그에 대한 답변도 찾아보고자 한다.

☘️ 

잘못된 정보가 있을 수 있습니다 

✔️  웹 - HTTP 기반으로 동작

• 서버 간에 데이터를 주고 받을 때 대부분 HTTP를 사용한다.
• 거의 모든 형태의 데이터 전송이 가능하다.

HTTP

: 웹 상에서 주고 받을 수 있는 프로토콜로 서버와 클라이언트 사이에 이루어지는 요청 응답 프로토콜이며, 주로 HTML 문서를 주고 받는데 사용한다.

웹 서버 (Web Server)

: HTTP 기반으로 동작하며 정적 리소스를 제공한다.

웹 애플리케이션 서버 (Web Application Server) 

: HTTP 기반으로 동작하며 프로그램 코드를 실행하여 애플리케이션 로직을 수행한다. 정적 리소스 제공도 가능하다.

Q. 웹 서버는 정적 리소스를 제공하고 웹 애플리케이션 서버는 애플리케이션 로직을 제공한다고 했다. 웹 페이지로 예시를 들면 어떤게 있을까?

A. 정적 리소스는 이미지, 동영상, CSS, HTML 등 이다. 웹 페이지에 로고가 있다면 로고는 이미지에 해당하니 웹 서버에서 제공하는 리소스가 될 것이다. 웹 애플리케이션 서버에서 제공하는 것은 로그인 페이지에서 사용자가 아이디와 비밀번호를 입력하면 입력된 데이터를 처리하여 로그인이 된 화면을 보여주는 이런 일련의 과정이라고 보면 될 것 같다. 단순히 보여주는 것에 끝나지 않고 로직을 수행하고 처리하는 과정이 웹 애플리케이션 서버가 행하는 일이다.

Q. 그런데 웹 애플리케이션 서버가 동적인 로직 뿐 아니라, 정적 리소스도 제공한다고 했다. 그러면 웹 애플리케이션 서버가 웹 서버가 하는 일도 처리하면 되지 않을까?

A. WAS는 비싼 비즈니스 로직을 수행한다. 예로 금전 거래, 개인정보관리, 주문 처리 등이 있을 수 있다. 이러한 로직은 처리 시간과 자원 소모가 크고 오류가 발생하게 된다면 서비스 전체에 심각한 영향을 줄 수 있다. 이런 복잡한 로직을 처리하는 WAS에게 정적인 리소스까지 제공하라고 한다면 정적인 리소스 제공을 처리하느라 중요한 로직의 처리가 미뤄질 수 있으며 요청을 받는 것 부터 처리까지 모든 것을 홀로 해야하는 WAS의 서버에 과부하가 올 수 있다. 그래서 웹 서버를 WAS의 앞에 배치시켜 요청이 오면 웹 서버에서 받게 한 후 동적으로 처리해야하는 부분만 WAS에게 요청을 위임한다.

✔️  서블릿과 서블릿 컨테이너

• 자바에서는 서블릿 컨네이터 기능을 제공하면 WAS라고 한다.

서블릿 (Servlet)

: 웹 상에서 주고 받을 수 있는 프로토콜로 서버와 클라이언트 사이에 이루어지는 요청 응답 프로토콜이며, 주로 HTML 문서를 주고 받는데 사용한다

서블릿 컨테이너 (Servlet Container)

: 서블릿들을 모아서 관리하고 웹서버와 소켓을 통신하는 역할을 한다. 대표적으로 톰캣이 있다.

@WebServlet(name = "helloServlet", urlPatterns = "/hello")
public class HelloServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) {
    }
}

/hello로 URL이 호출되면 그때 서블릿 코드가 실행된다. 서블릿이 주로 하는 것은 요청을 처리하고, 그에 맞는 응답을 보내는 것이다. 코드를 살펴보면 HttpServletRequest와 HttpServletResponse가 있다. 이는 각각 HTTP 요청 정보를 편리하게 사용하고, HTTP 응답 정보를 편리하게 제공하는 역할을 한다.

서블릿 컨테이너는 서블릿 객체를 싱글톤으로 관리한다. 사용자가 보내온 요청 객체와 응답 객체만 새롭게 생성한 후 이미 만들어져 있는 서블릿 객체를 재사용하여 성능을 최적화시킨다. 

Q. 왜 요청 객체와 응답 객체를 새롭게 생성하는걸까?

A. 사용자마다 요청하는 내용이 다르기 때문에 그에 대해 처리하는 응답도 달라질 것이다. 만약 같은 객체를 사용하게 된다면, 3만원을 결제한 사용자 A와 1만원 결제한 사용자 B에 대한 처리 응답이 섞일 것이다. 그래서 요청 객체와 응답 객체는 재사용하지 않으며 반드시 요청, 응답 관련 데이터는 HttpServletRequest와 HttpServletResponse 객체에 저장하고 사용해야 한다.

Q. 왜 서블릿 객체는 재사용해도 되는걸까?

A. 이 개념을 식당으로 비유해보고자 한다. 서블릿은 요리사라고 생각하고, 요청 객체와 응답 객체는 종업원이라고 생각하면 쉬울 것 같다. 요리사(서블릿)는 종업원(쓰레드)이 들고온 주문서(요청 객체)만 보고 요리를 만들고 종업원에게 내주기만 하면 된다. 요리사는 어떤 음식을 만들어야하는지만 확인하고, 이 음식을 몇 번 테이블에서 주문했고 이 음식을 요청한 테이블이 이전에 어떤 음식을 주문했는지는 몰라도 된다. 요리가 완성되어 나오면 종업원은 접시(응답 객체)를 들고 고객에게 줄 것이다. 서블릿 객체는 상태를 기억하지 않아도 되고, 그저 처리에만 집중하면 되기에 하나의 객체로 재사용할 수 있는 것이다.(어차피 종업원이 옮기는 거라 종업원이 몇 번 테이블에서 주문한 음식인지 기억한다. 테이블의 주문이 섞이지 않는다.) 한명의 요리사로 충분히 고객의 요청을 처리할 수 있다면 굳이 사장은 다른 요리사를 고용할 이유가 없다. 그리고 한 명의 요리사가 한 번에 하나의 요리만 하지 않고 여러 테이블에서 오는 요청을 동시에 처리할 수 있다. 여러 종업원글이 주문서를 들고 오는 것을 멀티쓰레드로 비유할 수 있을 것 같다. 

✔️  멀티쓰레드와 쓰레드 풀

멀티쓰레드 (Multi thread)

: 하나의 프로세스 내에서 둘 이상의 스레드가 동시에 작업을 수행한다.

쓰레드 풀 (Thread pool)

: 미리 일정 개수의 쓰레드를 생성하여 관리하는 기법이다.

요청 마다 쓰레드를 생성한 경우다. CPU나 메모리가 허용될 때 까지 동시에 요청된 것들을 처리할 수 있겠지만, 쓰레드의 생성 비용은 매우 비싸다. 고객이 요청할 때 마다 새로운 쓰레드를 생성하게 된다면 응답 속도가 늦어질 것이다. 또 쓰레드 생성에는 제한이 없다. 만약 고객의 요청이 너무 많이 오게 되면, CPU나 메모리 임계점이 넘어서 서버가 다운될 수 있다.

요청이 올 때마다 쓰레드를 만드는 것은 효율이 떨어지기 때문에 미리 쓰레드를 만들어둔다. 그걸 쓰레드 풀이라고 한다. 톰캣은 주로 200개를 기본 설정한다. 그럼 200개가 모두 다 사용하게 된다면, 남은 요청은 큐에서 대기하도록 한다. 쓰레드를 필요할 때 만들어서 쓴 경우는 생성에 제한이 없기 때문에 CPU나 메모리의 임계점이 넘어버려 서버가 죽을 수 있지만 쓰레드 풀로 쓰레드를 관리하면 과도한 요청들은 대기하도록 만들어 서버 폭주를 방지한다.

Q. 요청이 들어왔을 때 쓰레드를 만드는 것과 미리 쓰레드를 만드는 것은 결국 둘 다 쓰레드를 만드는 것인데 왜 성능에 차이가 나는걸까?

A. 쓰레드는 식당에서 일하는 종업원에 비유할 수 있다. 여러 종업원이 주문서와 요리 서빙을 동시다발로 하면 그 행위가 멀티쓰레드가 된다. 사장이 종업원을 여러명 고용한 후 손님의 요청이 많아지면 종업원을 내보내고 요청이 적어지면 다시 풀로 들어와 기다리게 한다. 그렇게 종업원을 고용하고 해고하기를 반복하는 것이 아니라, 이미 여러명을 고용해둔 뒤 풀이라는 대기실에서 기다리게 한 후 요청의 수만큼 돌린다고 생각하면 될 것 같다. 종업원을 고용하고 해고하기를 반복하면 당연히 더 많은 시간과 비용이 들 것이다. 이미 고용한 후 필요한 만큼 종업원을 돌리고 필요하지 않다면 대기하게 한 후 요청이 새롭게 들어오면 같은 종업원이 나가 요청을 처리하도록 하는 것이 바로 응대가 가능하기에 훨씬 효율적이다.

개발자는 쓰레드 풀의 숫자를 적정하게 설정하는 것이 매우 중요하다. 쓰레드 풀의 수를 너무 낮게 설정하면 요청은 대기 상태가 되고 고객의 요청에 대한 응답은 지연된다. 쓰레드 풀의 수를 너무 높게 설정하면 동시 요청이 많이 발생했을 때 CPU와 메모리의 임계점을 초과하게 되어 서버가 다운될 것이다. 적정 숫자를 찾는 방법은 로직이 얼마나 복잡한지, CPU와 메모리 그리고 IO 리소스 상황에 따라 다르기 때문에 아파치ab, 제이미터, nGrinder 툴로 성능 테스트를 시도하는 것이 좋다.

✔️  HTML 페이지와 HTML API 그리고 WAS가 어떻게 작성되는지

HTML 페이지

: 동적으로 필요한 HTML 파일을 생성해서 전달한다. 주로 사용자가 보는 홈페이지를 의미한다.

로그인 화면 예시

<form action="/login" method="post">
  <input name="username">
  <input name="password" type="password">
  <button type="submit">로그인</button>
</form>

사용자가 로그인을 할 수 있도록 보이는 페이지이며 사용자가 버튼을 누르면 /login 경로로 데이터가 post 방식으로 보내질 것이다.

HTML API

: HTML이 아닌 JSON이나 XML 형식으로 주고 받으며 프로그램이 데이터를 주고 받기 위한 인터페이스다.

자바스크립트의 로그인 API

fetch('/api/login', {
  method: 'POST',
  body: JSON.stringify({ username: 'sori', password: '1234' }),
  headers: { 'Content-Type': 'application/json' }
})
.then(response => response.json())
.then(data => console.log(data));

로그인 버튼이 눌렸을 때 화면에 적힌 데이터를 Controller까지 전달해주는 것이 HTML API(웹 API 혹은 REST API)가 하는 일이다. fetch 함수의 인자에는 들어온 경로와 어떤 방식으로 보내는지 어떤 내용을 어떻게 처리하여 보낼건지에 대해 적는다. 위의 코드는 login 경로로 들어온 정보를 POST(새로운 자원 요청)방식으로 보내며 username과 password는 JSON 문자열로 반환한다는 내용이 들어있다. 이 API 요청은 WAS의 Controller가 받아 처리한다.

HTTP API는 브라우저 같은 UI 클라이언트와 통신할 때만 사용하는 것이 아니다.서버와 서버 간에도 HTTP API를 통해 데이터를 주고받는다. 사용자가 상품을 주문한 뒤 결제 단계로 넘어가는 경우, 주문 서버와 결제 서버가 HTTP API를 통해 필요한 정보를 주고받는 방식으로 통신한다.

WAS의 Controller

@RestController
@RequestMapping("/api")
public class LoginController {

    @PostMapping("/login")
    public ResponseEntity<LoginResult> login(@RequestBody LoginRequest request) {       
       // 로직 수행 코드...
        return ResponseEntity.ok(new LoginResult("success", "Welcome!"));
    }
}

로그인을 처리하는 Controller다. @RequestMapping("/api")는 이 클래스의 모든 요청은 api로 시작된 경로만 처리하겠다는 의미이다. @PostMapping은 /api/login 경로 중 post 요청만 처리한다는 의미이다. 이렇게 경로를 통해 들어온 정보를 가지고 일련의 비즈니스 로직이 실행된다. 

실행되는 경로에 대해 다시 정리해보자면, HTML 페이지에 사용자가 로그인 관련 정보를 입력하여 버튼을 누르면, HTML API는 데이터를 어떤 형태로 어떤 경로로 보낼건지 정리하여 WAS로 보낸다. 그러면 WAS 내에 있는 Controller 중 @RestController가 API 요청을 받고 서블릿 컨테이너(예로 톰캣)가 요청을 전달한다. 전달된 요청에 맞춰 로그인 처리 로직이 수행되고 JSON 데이터로 생성된 결과는 API 응답으로 브라우저로 전달된다. 로그인이 제대로 처리되었다면 그에 맞는 화면을 사용자가 받게 될 것이다.

✔️  브라우저 렌더링, 서버사이드 렌더링, 클라이언트 사이드 렌더링

브라우저 렌더링

: 브라우저가 서버로부터 요청해 받은 내용을 브라우저 화면에 표시해주는 작업을 말한다.

SSR (서버사이드 렌더링)

:  정적인 화면에 사용하며, HTML 최종 결과를 서버에서 만들어서 웹 브라우저에 전달한다.

서버사이드 렌더링 방식은 보통 백엔드 지향 개발자들이 Spring과 Thymeleaf 등을 사용해 화면과 로직을 함께 처리하며, 간단한 프로젝트를 만드는 데 자주 활용되는 방식으로 보면 적합할 것 같다.

CSR (클라이언트 사이드 렌더링)

: 동적인 화면에 사용하며, HTML 결과를 자바스크립를 사용해 웹 브라우저에서 동적으로 생성해서 적용한다.

클라이언트 사이드 렌더링 방식이 웹 프론트엔드와 백엔드가 나뉘어 프로젝트를 수행하는 것으로 생각하면 될 것 같다. Vue.js, React를 사용하여 동적인 화면을 제공하고 백엔드 개발자는 데이터 API와 비즈니스 로직 등을 처리한다.

아래에 출처를 남겨두겠습니다.
블로그엔 제가 최대한 이해한 내용까지만 적는거라
출처에 들어가시면 더 많은 내용이 있어 공부하시는데 도움되실겁니다.

🪽

틀린 내용이 있다면 댓글로 알려주세요

- 웹서버와 웹 애플리케이션 서버의 차이

- 웹과 HTTP

- WAS와 서블릿

- fetch와 post

- fetch

- 브라우저 렌더링, CSR과 SSR

#6083_ 빛 섞어 색 만들기.

입력 : 2 2 2

출력 : 0 0 0
      0 0 1
      0 1 0
      0 1 1
      1 0 0
      1 0 1
      1 1 0
      1 1 1
      8

내풀이

r, g, b = map(int, input().split())
cnt = 0

for i in range(r):
    for j in range(g):
        for k in range(b):
            print(i, j, k)
            cnt += 1
print(cnt)

정답풀이

r, g, b = input().split()

r = int(r)
g = int(g)
b = int(b)

for i in range(0, r) :
  for j in range(0, g) :
    for k in range(0, b) :
      print(i, j, k)

print(r*g*b)

#6089_ 수 나열하기2.

입력 : 2 3 7

출력 : 1458

내풀이

a,r,n = map(int,input().split( ))
print(a*(r**(n-1)))

내풀이

a, r, n = map(int, input().split())
ans = a*r

for i in range(0, n-2) :
  ans = ans*r

print(ans)

정답풀이

a, r, n = input().split()

a = int(a)
r = int(r)
n = int(n)

for i in range(1, n) :
  a = a*r

print(a)

** 연산자는 거듭제곱 연산자로 **의 왼쪽의 피연산자를 밑, 오른쪽의 피연산자를 지수로 한 값을 구한다.
도움이 될 수 있으니 풀이를 적어보자면, 입력으로 들어온 값 중 7을 살펴보면 그 의미는 7번째 수를 구하라는 뜻이다. 첫번째 내풀이에서 n-1인 이유는 a자체가 첫번째 수가 되니까 굳이 연산을 할 필요가 없어서 n에서 하나를 차감한 채 시작하는 것이고 두번째 내풀이에서 n-2인 이유는 첫번째 수 a, 두번째 수 a*r(ans)이라서 두 개의 과정을 제외해야하기 때문에 n-2를 해줬다.
2 - 6 - 18 - 54 - 162 - 486 - 1458 이렇게 7번째 수를 구하면 된다.

#6091_ 함께 문제 푸는 날.

입력 : 3 7 9

출력 : 63

내풀이

import math

a,b,c = map(int, input().split( ))

def lcm(x,y) :

 return(x*y)//math.gcd(x,y)

result = lcm(lcm(a,b),c)

print(result)

정답풀이

a, b, c = map(int, input().split())
d = 1

while(d%a!=0 or d%b!=0 or d%c!=0) :
  d = d+1

print(d)

내풀이는 유클리드 호제법을 사용한 풀이다. 파이썬은 다양한 내장 라이브러리가 있어 알고리즘 문제를 푸는데 코드가 짧게 단축된다는 장점이 있다. 그 중 math 라이브러리가 수학 관련 함수가 들어있어, 삼각함수 혹은 제곱근 등 다양한 문제를 쉽게 풀 수 있도록 도와준다.
lcm은 최소공배수를 구하는 함수로 사용자가 정의한 것이고 그 안에 math.gcd라는 math 라이브러리에 속한 gcd 함수를 사용하여 최소공배수를 구할 수 있다. gcd는 최대공약수를 구하는 함수로 두 수인 x와 y를 0이 될 때 까지 나누고 나눠진 수를 두 자연수의 곱에 나누면 최소공배수를 구할 수 있다.

​

#6092_ 이상한 출석 번호 부르기1.

입력 : 10
      1 3 2 2 5 6 7 4 5 9
      
출력 : 1 2 1 1 2 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

내풀이

a = int(input())
num = list(map(int,input().split()))
att = list()

for i in range(24):
  att.append(0)

for i in range(a):
  att[num[i]] = att[num[i]]+1

for i in range(1, 24):
  print(att[i], end=" ")

정답풀이

n = int(input())
a = input().split()

for i in range(n) :
  a[i] = int(a[i])

d = []
for i in range(24) :
  d.append(0)

for i in range(n) :
  d[a[i]] += 1

for i in range(1, 24) :
  print(d[i], end=' ')

리스트를 만들 때 꼭 어떤 수로든 채워넣어줘야한다. 안그러면 0번지, 1번지 등 인덱스로 접근하려고 할 때 리스트가 비어있어 해당 인덱스가 존재하지 않아 오류가 발생한다.

#6093_ 이상한 출석 번호 부르기2.

입력 : 10

출력 : 5 8 9 7 6 6 3 2 4 10

내풀이

a = int(input())
b = a-1
num = list(map(int,input().split()))

for i in range(a) :
  print(num[b-i],end=" ")

내풀이

n = int(input())
a = list(map(int,input().split( )))

d = []
for i in range(n) :
  d.append(a[i])

d.reverse()

for i in range(n) :
  print(d[i], end=" ")

정답풀이

n = int(input())
a = input().split()

for i in range(n) :
  a[i] = int(a[i])

for i in range(n-1, -1, -1):
  print(a[i], end=' ')

d.reverse( )는 현재 리스트를 그대로 거꾸로 뒤집어준다. (역순정렬이 아님)

#6063_ 정수 두 개 입력받아 큰 값 출력하기. (삼항연산자 사용할 것)

입력 : 123 456

출력 : 456

내풀이

a,b = map(int,input().split())
c = a if a>b else b
print(c)

내풀이

a,b = map(int,input().split())
print(a) if a>b else print(b)

정답풀이

a, b = input().split()
a = int(a)
b = int(b)
c = a if a>=b else b
print(c)

삼항연산자는 [참일때] if [조건문] else [거짓일때] 형태로 쓰이며 코드가 간결해보인다는 장점이 있지만, 오히려 복잡한 연산의 경우 가독성이 더 떨어져 보일 수 있다.

- 삼항 연산자

#6071_ 0이 입력될 때까지 무한 출력하기.

출력 : 7
      4
      2
      3
      0
      1
      
입력 : 7
      4
      2
      3

내풀이

while True :
    a = int(input())
    if a == 0 :
        break
    print(a)

정답풀이

while True:
    a=input()
    a=int(a)
    if a==0:
        break
    else:
        print(a)

정답풀이

n = 1

while n != 0 :
  n = int(input())
  if n != 0 :
    print(n)

#6074_ 문자 한 개 입력받아 알파벳 출력하기

입력 : f

출력 : a b c d e f

내풀이

a = ord(input())
c = 97

while a >= c :
  print(chr(c), end = " ")
  c = c+1

정답풀이

c = input()
i = ord('a')
c = ord(c)

while i<=c:
    print(chr(i), end=' ')
    i+=1

ord('A')는 65이고, ord('a')는 97이다.

#6081_ 16진수 구구단 출력하기.

입력 : B

출력 : B*1=B
      ...
      B*F=A5

내풀이

a = int(input(),16)
b = int('F',16)
c = int('1', 16)

while c <= b :
  print('%X'%a+'*'+'%X'%c+'='+'%X'%(a*c))
  c = c+1

정답풀이

n = int(input(), 16)

for i in range(1, 16) :
  print('%X'%n, '*%X'%i, '=%X'%(n*i), sep='')

16진수를 표현할 때 %X(대문자표현)와 %x(소문자표현)를 사용한다.  8진수를 표현할 때 %O(대문자표현)와 %o(소문자표현)를 사용한다. 16진수와 8진수를 사용하는 이유는 2진수로 값을 표현하기에 너무 길기 때문이다. 16진수와 8진수 모두 2진수의 제곱의 형태로 길어진 2진수의 값을 짧게 표현할 수 있다.

- 2진수 8진수 16진수를 쓰는 이유

#6082_ 3 6 9 게임의 왕이 되자.

입력 : 9

출력 : 1 2 X 4 5 X 7 8 X

내풀이

a = int(input())

for i in range (1, a+1) :
  b = i%10
  if b==3 or b==6 or b==9 :
    print('X',end=" ")

  else :
    print(i, end=" ")

내풀이

a = int(input())

for i in range(1, a+1):
  if str(i).count('3')+str(i).count('6')+str(i).count('9') :
    print("X", end =" ")
  else :
    print(i, end=" ")

정답풀이

n = int(input())

for i in range(1, n+1) :
  if i%10==3 or i%10==6 or i%10==9 :
    print("X", end=' ')
  else :
    print(i, end=' ')

i값을 str인 문자열로 받고, 문자열 i에 3과 6 그리고 9라는 문자가 한 번이라도 나오면 X가 출력되도록 만들었다. 여기서 count( )는 괄호 안에 적인 글자가 몇 번 나오는지 세는 함수다.

#6033_ 문자 한 개 입력받아 다음 문자 출력하기.

입력: a
출력: b

내풀이

a = ord(input())
print(chr(a+1))

정답풀이

a=input()
b=ord(a)+1
c=chr(b)
print(c)

ord는 문자 -> 숫자로, chr는 숫자 -> 문자로 변환한다.
문자가 들어왔고 그 값을 숫자로 바꾼 후 a에 넣는 것이니 a에는 숫자가 들어가 있다.
그리고 a의 값에 1을 더한 값을 다시 문자로 바꾸면 하나의 값이 상승한 문자가 출력된다.

#6042_ 실수 1개 입력받아 소숫점 이하 자리 변환하기.

입력: 3.141592

출력: 3.14

내풀이

a = float(input())
print(format(a,".2f"))

정답풀이

f = float(input())
print(round(f,2))

format 메서드는 문자열을 구성하는데 사용한다. format 메서드 중괄호 안에 변수나 값을 넣을 수도 있고 형식 지정자도 추가할 수 있다.  round 메서드는 숫자 중 가장 가까운 정수로 반올림한다. 그 외 ceil과 floor로 올림과 내림을 반환하는 메서드도 있다.

- format()함수 사용법 정리 출처

- round() ceil() floor() 출처

#6048_ 정수 2개를 입력받아 비교하기.

입력 : 1 9

출력 : True

내풀이

a,b = map(int, input.split())
if (a<b) :
    print(True)
else :
    print(False)

정답풀이

a, b = input().split()
a = int(a)
b = int(b)
print(a<b)

#6048_ 둘 다 참일 경우만 참 출력하기.

입력 : 1 1

출력 : True

내풀이

a,b = map(int, input().split())

if a >0 and b>0 :
  print(True)
else :
  print(False)

정답풀이

a, b = input().split()
print(bool(int(a)) and bool(int(b)))

Bool 자료형
1. 문자열의 경우 비어있으면 False, 비어있지 않으면 True
2. 리스트의 경우 비어있으면 False, 비어있지 않으면 True
3. 숫자형의 경우 0이면 False, 0이 아니면 True
4. None 값은 False

#6059_ 비트 단위로 NOT하여 출력하기.

입력 : 2

출력 : -3

내풀이&정답풀이

a = int(input())
print(~a)

~a = -a-1 = -(n+1)로 틸드 연산자를 통해 음수를 표현할 수 있다. 어떤 리스트에서 뒤에서 n번째 값을 알고 싶거나 반전된 상태가 알고 싶을 때 (일부 비트 조작 알고리즘) 사용한다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   제네릭을 사용하지 않는 경우_ 585p

• 객체를 저장하는 클래스

class Onion { }

class Goods1 {
    private Onion onion = new Onion();
    public Onion get() {
        return onionl
    }
    
    public void set(Onion onion) {
        this.onion = onion;
    }
}

Goods1 g1 = new Goods1();
g1.setOnion(new Onion());
Onion onion = (Onion)g1.get();

Onion 클래스와 Onion 클래스를 담을 수 있는 Goods1 클래스가 있다. Goods1은 Onion 클래스만 담을 수 있으니 Onion이 아닌 다른 것을 담고 싶어지면 새로운 클래스를 생성해야한다. 하지만 어떤 코드는 하나의 클래스에 다양한 클래스를 담고 싶을 수도 있다.

• Object로 정의한 클래스

class Onion {}
class Radish {}

class Goods {
    private Object object = new Object();
    public Object get() {
        return object;
    }
    public void set(Object object) {
        this.object = object;
    }
}

Goods g1 = new Goods();
g1.set(new Onion());
Onion onion = (Onion)g1.get();

Goods g2 = new Goods();
g2.set(new Radish());
Radish radish = (Radish)g2.get();

Onion과 Radish는 모두 Object 타입의 자식이다. 왜냐하면 자바에서 모든 클래스의 최상위 부모는 Object를 상속받기 때문이다. 예제 코드는 set( ) 메서드를 통해 객체를 저장하고, get( ) 메서드를 통해 저장된 값을 꺼낸다.

맨 처음 제너릭 없이 객체를 저장한 클래스의 예시를 살펴보자. 객체를 저장할 때 g1.setOnion이라고 적었다. 하지만 Object로 정의한 코드를 살펴보면 g1.set(new Onion());으로 Onion이 Object 타입으로 저장되어있다. 이 점에서 두 코드의 차이를 확인할 수 있다.

Object 타입으로 저장했으니 get에서도 Object 타입으로 꺼낼 것 같지만 사실 그렇지 않다. 꺼낼 때는 객체를 사용하기 위해 Onion과 Radish 객체로 다운 캐스팅해야 한다. 만약 잘못 캐스팅이 된 경우 ClassCastException 실행 예외가 발생하며 프로그램이 종료된다. 이를 약한 타입 체크라고 한다. 

✔️   제네릭 문법_ 591p

• 제네릭

: 클래스 내부에서 사용할 데이터 타입을 외부에서 지정하는 기법

• 강한 타입 체크

: 잘못된 캐스팅을 할 때 문법 오류를 발생시켜 잘못된 캐스팅으로 발생할 수 있는 문제를 사전에 예방

• 제네릭 타입 변수의 관례적 표기 및 의미

class KeyValue<K, V> {
    private K key;
    private V value;
    public K getKey() {
        return key;
    }
    
    public void setKey(K key) {
        this.key = key;
    }
    
    public void setValue(V value) {
        this.value = value;
    }
}

KeyValue<String, Integer> kv1 = new KeyValue<>();
kv1.setKey("사과");
kv1.setValue(1000);
String key1 = kv1.getKey();
int value1 = kv1.getValue();
System.out.println("key: " + key1 + "value: " + value1);

KeyValue<String, Void> kv2 = new KeyValue<>();
kv2.setKey("키 값만 사용");
String key2 = kv2.getKey();
System.out.println("key: " + key2);

kv1과 kv2의 타입이 다르게 설정할 수 있는 이유는 제네릭 클래스는 클래스를 정의하는 시점에 타입을 지정하는 것이 아닌 객체를 생성하는 시점에 타입을 지정하기 때문이다. 그래서 하나의 제네릭 클래스로 다양한 타입의 값을 저장 및 관리할 수 있는 객체를 생성할 수 있는 것이다.

Object 타입의 필드와 제네릭의 가장 큰 차이점은 setter 메서드를 사용할 때 입력 타입을 정확히 확인할 수 있고, 다운캐스팅을 하지 않아도 해당 타입으로 알아서 리턴된다는 것이다. 만약 kv2의 setKey에 문자열이 아닌 숫자를 대입하거나 get할 때 String이 아닌 다른 타입으로 꺼내는 경우 강한 타입 체크로 인해 문법 오류 발생이 일어난다. 

코드를 살펴보자 KeyValue<String, Integer> kv1 = new KeyValue<>();에서  KeyValue<String, Integer> kv1 = new KeyValue<String, integer>();으로 작성해도 된다. 그러나 제네릭 타입은 항상 왼쪽 항과 동일하기 때문에 생략할 수 있다. 위의 코드에서는 제네릭 타입 변수를 2개 가진 경우로 작성되었는데, 만약 하나의 타입만 필요한 경우 Void를 적으면 된다. 

✔️   제네릭 메서드_ 597p

• 제네릭 메서드

: 일반 클래스 내부의 특정 메서드만 제네릭으로 선언한 경우

class GenericMethods{
    public <K,V> method1(K k, V v) {
        System.out.println(k + ":" + v);
    }
}

GenericMethods gm = new GenericMethods();

gm.<String, Integer>method1("국어", 80);
gm.method1("국어", 80);

일반 클래스 GenericMethods 내에 제네릭 메서드로 2개의 제네릭 타입 변수를 사용하고 있다. 참조객체 gm을 활용한 코드를 보면 실제 제네릭 타입이 어떤 타입이지 정의해둔 코드와 생략한 코드를 볼 수 있다. 입력매개변수를 통해 제네릭 타입이 어떤 타입인지 알 수 있기 생략해도 무관하다. 다만 입력매개변수 자체가 없거나 입력매개변수에서 제네릭 타입 변수를 사용하지 않는 public static <T> void doSomething() 이런 예시 코드의 경우 입력값으로 예측할 수 없기 때문에 생략이 불가하다.

• 제네릭 Object 타입

public <T> void method(T t) {
    System.out.println(t.equals("안녕"));
}

위의 코드는 타입에 제한이 없는 코드다. 이런 경우 컴파일 시 T를 Object로 간주하여 Object에 정의된 메서드 hashcode, eqauls, toString 등만 사용가능하다. 이렇게 되면 제네릭 메서드의 활용 범위가 매우 좁아지게된다.

아래에 정리되겠지만, 그래서 이런 경우 더 넓게 활용하기 위해 제네릭 타입의 범위를 제한한다. 현재 코드에서 t.equals가 아닌 t.length인 String 메서드를 사용하고 싶은 경우 <T>를 <T extends String>으로 변경하면 String 클래스에 있는 메서드도 사용가능해진다.

✔️   제네릭 타입 범위 제한_ 602p

• 제네릭 클래스 타입 범위 제한

class A {}
class B extends A {}
class C extends B {}

class D <T extends B> {
    private T t;
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
}

D<B> d2 = new D<>();
D<C> d3 = new D<>();
D d4 = new D();

d2.set(new B());
d2.set(new C());

d3.set(new C());

d4.set(new B());
d4.set(new C());

제네릭 클래스의 타입 제한하는 방법은 제네릭 타입으로 대입될 수 있는 최상위 클래스를 extends 키워드와 함께 정의하는 것이다. 그래서 <제네릭 타입 변수 extends 상위 클래스>의 형태로 사용하며 이때 extends는 상속하라는 의미가 아닌 최상위 클래스 혹은 인터페이스로 지정한다라는 의미로 가진다.  코드에서는 <T extends B> 로 작성했으며 A <- B <- C의 상속 구조를 갖고 있다. 

제네릭 클래스 D를 살펴보자. 클래스 D는 클래스 B 또는 클래스 B의 자식 클래스만 오도록 제한했다. 그렇다는 것은 A는 제한에 걸려 D<A> d1 = new D<>(); 객체 생성이 불가하다는 의미이다. d2는 제네릭 타입으로 B를 지정하여 B와 C 객체가 입력가능하다. 그런데 d3는 C 타입으로 지정했기 때문에 C의 상위클래스 B객체를 입력할 수 없다. d4는 타입을 지정하지 않았지만 모든 타입의 최상위 클래스가 <B> 타입이므로 제네릭 타입으로 대입되었다. 그래서 d4는 B와 C 객체가 입력가능하다. 

• 제네릭 메서드 타입 범위 제한

class A {}
class B extends A {}
class C extends B {}
class D extends C {}

class Goods <T> {
    private T t;
    public T get() {
        return t;
    }
    public void set(T t) {
        this.t = t;
    }
}

void methods(Goods<A> g) {}
void methods(Goods<?> g) {}
void methods(Goods<? extends B> g) {}
void methods(Goods<? super B> g) {}

extends는 아까와 같이 해당 클래스와 자식 클래스만 가능하다. 그럼 코드에서 B라고 적혀있으니 B 클래스와 B의 자식 클래스인 객체가 들어갈 것이다. super는 해당 클래스와 부모 클래스인 객체만 가능하므로  B 또는 B의 부모 클래스만 가능할 것이다.

상속구조를 살펴보면 A <- B <- C <- D가 된다. Goods<A>는 A인 객체만 가능하고 Goods<?> 모든 타입인 객체가 가능하기에 A, B, C, D 타입이 모두 ? 자리에 올 수 있다. Goods<? extends B>는 B 또는 B의 자식 클래스인 객체만 가능하기에 B, C, D 타입이 가능하며 Goods<? super B>는 B 또는 B의 부모 클래스인 객체만 가능해서 A, B가 제네릭 타입으로 지정될 수 있다. 

✔️   제네릭의 상속_ 612p

• 제네릭 클래스의 상속

class Parent {
    <T extends Number void print(T t) {
        System.out.println(t);
    }
}

class Child extends Parents {
}

Parent p = new Parent();
p.<Integer>print(10);
p.print(10);

Child c = new Child();
c.<Double>print(5.8);
c.print(5.8);

부모클래스가 제네릭 클래스인 경우 자식 클래스도 제네릭 클래스가 되어 제네릭 타입 변수를 자식 클래스가 그대로 물려받게 된다. 또한 자식 클래스에서 제네릭 타입 변수를 추가해 정의할 수도 있다. 그러므로 자식 클래스의 제네릭 타입 변수의 개수는 언제나 부모와 같거나 그 이상일 것이다.

코드를 보면 부모 클래스에 최상위 제네릭 타입이 Number로 제한되어 있다. Number 클래스는 boolean과 char을 제외한 Byte, Short, Integer, Long, Float, Double이 있다. 자식 클래스는 Number 클래스 내에 있는 6가지 자료형을 사용할 수 있으며 부모 클래스가 가지고 있는 print( )메서드도 이용할 수 있다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   동기화_ 539p

• 동기화

: 하나의 작업이 완료된 후 다른 작업을 수행하는 것

• 비동기화

: 하나의 작업 명령 이후 완료 여부와 상관없이 바로 다른 작업 명령을 수행하는 것

• 메서드 동기화

: 2개의 쓰레드가 동시에 메서드를 실행할 수 없다는 것

접근지정자 synchronized 리턴타입 메서드명(입력매개변수){ }

메서드를 동기화할 때는 동기화하고자 하는 메서드의 리턴 타입 앞에 synchronized 키워드만 넣으면 된다. 이렇게 되면 동시에 2개의 쓰레드에서 해당 메서드를 실행할 수 없게된다. 

• 블록 동기화

: 2개의 쓰레드가 동시에 해당 블록을 실행할 수 없다는 것

어떤 메서드 {
    synchronized (임의의 객체) { }
}

전체 메서드를 동기화하지 않고 원하는 부분만 동기화할 수 있게 한다. 필요한 코드만 동기화를 진행하기 때문에 메서드 동기화보다 더 정밀하게 코드를 설정할 수 있다. 여기서 임의의 객체란 내가 선택한 어떤 객체로 잠금을 설정하겠다는 의미로 생각하면 되고 주로 this를 사용해서 현재 인스턴스 객체로 잠금을 설정한다. 그러면 이 잠근 객체와 같은 객체를 가지는 블록들은 동시 사용이 불가하다.

• 메서드 동기화와 블록 동기화

class MyData {
    
    Object keyObject = new Object();
    synchronized void abc() {
    ...
    }
    
    synchronized void bcd() {
    ...
    }
    
    synchronized void cde() {
    ...
    }
    
    void def() {
        synchronized (keyObject) {
        ...
        }
    }
    
    void efg() {
        synchronized (keyObject) {
        ...
        }
    }
}

abc와 bcd는 동기화 메서드이다. cde와 def 그리고 efg는 동기화 블록을 가지고 있다. 여기서 주의 깊게 봐야할 점은 어떤 메서드가 동기화 메서드인지 동기화 블록인지가 아니다. 각 메서드와 블록이 어떤 키로 잠금이 되어있는지를 봐야한다. abc와 bcd 그리고 cde는 this 객체로 잠금이 되어있다. 그러면 abc,bcd,cde는 동시에 사용할 수 없다. def와 efg는 keyObject로 잠금이 되어있다. 그러면 def와 efg는 동시에 사용할 수 없다.

여기서 각 키는 this와 keyObject로 나뉜다. 키가 다르다면? 동시에 사용가능하다. abc는 cde와 동시에 사용 불가하지만 abc가 def와 동시 사용은 가능할 것이다. 동기화에서 중요한 것은 어떤 객체로 잠금을 설정했는지다.

아마 같은 키를 가지는 메서드를 동시에 사용 불가한 이유는 키가 하나이기 때문일 것이다. 처음에 abc가 키를 선점하고 해야할 활동을 마치면 abc는 키를 반납할 것이다. 이때 키는 다음 순서인 bcd로 넘어가지 않는다. bcd와 cde가 반납된 키를 가지기 위해 서로 경쟁할 것이고 키를 선점한 메서드가 먼저 활동하게 된다.

✔️   쓰레드 6가지 상태_ 552p

• NEW 상태

: Thread 객체를 new 키워드를 이용해 생성한 시점인 실행 이전 상태

Thread thread = new Thread() {
    @Override
    public void run() {
        for(long i = 0; i < 1000000000L; i++) {}
    }
}

• RUNNABLE 상태

: start( ) 메서드를 호출한 상태, 실행 상태로 언제든지 갈 수 있는 상태

thread.start();

• TERMINATED 상태

: run( ) 메서드가 완전히 종료된 실행을 마친 상태

try {
    myTread.join();
} catch (InterruptedException e) {}

• TIMED_WAITING 상태

: 정적 메서드인 Thread.sleep 또는 인스턴스 메서드인 join이 호출된 상태

 Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(2000); // 2초 동안 기다림
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

Thread t2 = new Thread(() -> {
            try {
                t1.join(1000); // 최대 1초 동안 t1을 기다림
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

위의 코드는 Runnable 상태에서 일시정지 상태로 전환되는 TIMED_WAITING 상태이다. TIMED_WAITING 상태는 주로 sleep(long millis)를 호출하거나 join(long millis)가 호출됐을 때다. 

Thread.sleep( )은 이 메서드를 호출한 쓰레드를 일시 정지하라는 의미로 일시정지 시간 동안 CPU를 어떤 쓰레드가 사용하든 상관하지 않는다. 쓰레드 객체.join( ) 메서드는 특정 쓰레드 객체에게 일정 시간 동안 CPU를 할당하라는 의미다.

쓰레드 t1은 sleep 메서드로 일시정지가 되었고 2초의 시간동안 어떤 쓰레드가 CPU를 사용하든 신경쓰지 않을 것이다. 그러나 쓰레드 t2는 join 메서드를 사용했기에 t2가 잠시 멈춘 1초 동안 t1 쓰레드가 CPU를 사용하도록 했다.

• BLOCKED 상태

: 동기화 메서드 또는 동기화 블록을 실행하고자 할 때 이미 다른 쓰레드가 해당 영역을 실행하고 있는 경우 발생.

Thread t1 = new Thread("thread1") {
    public void run() {
        mc.syncMethod();
    };
};  

Thread t2 = new Thread("thread2") {
    public void run() {
        mc.syncMethod();
    };
}; 

Thread t3 = new Thread("thread3") {
    public void run() {
        mc.syncMethod();
    };
};

쓰레드 t1이 먼저 실행하고 있을 때, t1이 실행을 완료하고 해당 동기화 영역의 열쇠를 반납할 때까지 기다려야한다. 이때 이런 상황을 BLOCKED 상태라고 한다. 

t1이 반납을 하게 되면 그 다음 순서인 t2가 키를 가질 것 같지만 사실 그렇지 않다. 키가 반납된 순간부터 t2와 t3는 서로 키를 가지기 위해 경쟁할 것이다. 그렇게 먼저 키를 가지게 된 쓰레드가 t1 다음으로 실행하게 될 것이다.

void startAll() {
    t1.start();
    t2.start();
    t3.start();
}

startAll 메서드에서 t1, t2, t3 쓰레드가 동시에 실행하려고 한다. 그러면 당연하게 t1, t2, t3는 경쟁할 것이고 키를 차지한 쓰레드 먼저 실행되며 나머지 두 쓰레드는 BLOCKED 상태가 될 것이다.

• WAITING 상태

: 쓰레드가 무한정 기다리고 있는 상태

Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

시간을 지정하지 않은 join 메서드 또는 object.wait 메서드를 사용하게 되면 WAITING 상태가 된다. join은 다른 쓰레드가 끝날때까지 기다려야하고 wait는 notify( )로 깨울 수 있다. 

lock 객체로 잠금을 건 쓰레드 t는 lock.wait( )으로 lock을 잠깐 반납했다. 언제까지 반납할지 시간을 지정하지 않았기 때문에 notify( )로 호출하여 WAITING 상태에서 빠져나오도록 해야한다.

synchronized (lock) {
    lock.notify(); 
        }

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   프로그램,  프로세스, 쓰레드_ 511p

• CPU 

: 연산을 수행함으로써 실제 프로그램을 실행하는 장치로, 가장 빠른 속도로 동작.

• 하드디스크

: 데이터의 저장 역할을 수행하며, 상대적으로 가장 낮은 속도로 동작.

• 메모리

: 저장된 데이터를 CPU로 보내는 역할을 하며, CPU와 근접한 속도로 동작.

• 프로그램

: 하드디스크에 저장된 파일들의 모임.

• 프로세스

: 메모리상에 로딩된 프로그램으로 메모리는 필요한 부분만을 동적으로 로딩.

• 멀티프로세스

: 하나의 응용 프로그램에 대해 동시에 여러 개의 프로세스를 실행할 수 있게 하는 기술.

• 쓰레드

: 여러 개의 작업이 동시에 수행되도록 하기 위해서 한정된 코어의 수를 갖는 CPU에 여러 개의 작업을 나눠 사용하며, CPU를 사용하는 최소 단위.

• 단일 쓰레드

public class ThreadExample01 {
    public static void main(String[] args) {
    
        for (int i = 1; i <= 5; i++) {
            System.out.println("작업 1 - i: " + i);
            try {
                Thread.sleep(500); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        for (int j = 1; j <= 5; j++) {
            System.out.println("작업 2 - j: " + j);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

해당 코드는 단일 쓰레드를 나타낸 것이다. 첫번째 for문과 두번째 for문이 번갈아가며 나오길 원했지만 단일 쓰레드로 첫번째 for이 모두 수행된 다음 두번째 for문이 수행된다.

• 멀티쓰레드

: 하나의 프로세스 안에서 여러 개의 쓰레드가 있는 것

① extends Thread + 3개의 쓰레드

class Task1 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("작업 1 - i: " + i);
            try {
                Thread.sleep(500); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Task2 extends Thread {
    @Override
    public void run() {
        for (int j = 1; j <= 5; j++) {
            System.out.println("작업 2 - j: " + j);
            try {
                Thread.sleep(500); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample02 {
    public static void main(String[] args) {
        Task1 t1 = new Task1(); 
        Task2 t2 = new Task2(); 

        t1.start();
        t2.start(); 
    }
}

쓰레드에는 동시성(concurrency)과 병렬성(parallelism)이 있다. 동시성은 처리할 작업의 수가 CPU의 코어 수보다 많을 때 각 작업의 쓰레드의 요청 작업을 번갈아가면서 실행한다. 매우 짧은 간격으로 교차 실행하기 때문에 사용자는 두 작업이 마치 동시에 실행되는 것처럼 보인다. 병렬성은 CPU의 코어 수가 작업 수보다 많을 때로 각각의 작업을 각각의 코어에 할당해 동시에 실행하도록 한다. 

여러 작업이 있고 여러 CPU가 있다고 가정하자. 그러면 개발자는 어느 작업을 멀티 쓰레드로 진행할건지 코드로 적어두면 된다. 그 다음 JVM이 운영체제로 해당 쓰레드를 넘기고 운영체제는 각 쓰레드를 어느 CPU에 배분할지 알아서 정한다. (보통 배분은 스케줄러가 한다)

위의 코드를 살펴보자. extends Thread로 Thread를 상속받았고 Thread 내부엔 run( )메서드가 있다. 그래서 Thread를 상속받은 클래스에 run( ) 메서드 안에 어떤 동작을 수행할지 재정의하면 오버라이딩되어 Thread에서 재정의한 동작을 수행하게 된다.

쓰레드에서 특이한 점이 있다. 메서드 run을 재정의했으니 run을 실행시키면 될텐데, run( )이 아닌 start( )가 적혀있다. 쓰레드가 실제 CPU와 이야기하기 위해서 자신만의 스택 메모리에 포함해 준비해야 할 것이 많다. 여기서 start 메서드가 준비단계 포함한 run 메서드 실행을 의미한다. start( )는 새로운 쓰레드 생성/추가하기 위한 모든 준비 + 새로운 쓰레드 위에 run( ) 실행이다.

② extends Thread + 2개의 쓰레드

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("작업 1 - i: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample03 {
    public static void main(String[] args) {
        MyThread t = new MyThread(); 
        t.start();

        for (int j = 1; j <= 5; j++) {
            System.out.println("작업 2 - j: " + j);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

앞에 있었던 예제를 살펴보면 그저 for문만 있었는데 단일쓰레드, extends Thread가 2개였는데 총 3개의 쓰레드였고, 이번 코드는 extends Thread가 1개인데 총 2개의 쓰레드이다. 그 이유를 살펴보면 main에 있다. 개발자가 명시하지 않아도 자바 프로그램이 실행될 때 JVM은 자동으로 main 쓰레드를 생성한다. 그래서 해당 코드 main에 적어둔 for문이 멀티 쓰레드로 작동하게 된다.

③ Runnable + 3개의 쓰레드

class Task1 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("작업 1 - i: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Task2 implements Runnable {
    @Override
    public void run() {
        for (int j = 1; j <= 5; j++) {
            System.out.println("작업 2 - j: " + j);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample04 {
    public static void main(String[] args) {
        Runnable task1 = new Task1();
        Thread t1 = new Thread(task1);
        t1.start();
        
        Runnable task2 = new Task2();
        Thread t2 = new Thread(task2);
        t2.start();
    }
}

Runnable 인터페이스를 구현한 클래스를 정의하고, run( ) 추상 메서드를 구현하면서 쓰레드의 작업 내용을 작성했다. 그리고 main에서 Runnable 객체를 생성했다.

extends Thread와 차이점이 있다. 바로 Runnable 객체의 내부에는 start( ) 메서드가 존재하지 않는다는 것이다.  그래서 main을 보면 start( )를 가지고 있는 Thread 객체를 생성해서 Thread 객체로 감싸 start( )를 호출했다. 

Runnable로 구현했을 때의 장점은 인터페이스기 때문에 다른 클래스를 상속할 수 있다는 것이다. 상속은 한 번만 되는데 쓰레드를 상속해버리면 다른 클래스를 상속할 수 없게된다. 

✔️   쓰레드의 속성_ 527p

• currentThread( )

: 연산을 현재 쓰레드 객체의 참좃값을 얻어올 수 있다.

new Thread(() -> {
    System.out.println("작업 시작");
}).start();

System.out.println("main 스레드 이름: " + Thread.currentThread().getName());
 
 or
 
Thread current = Thread.currentThread()
System.out.println("현재 스레드 이름: " + current.getName());

위의 코드는 참조 변수 없이 실행한 코드이다. 이렇게 참조 변수 없이 일회성으로 쓰레드를 실행할 경우 .getName( ) 같은 객체의 속성을 가져올 수 없다. 그래서 static Thread Thread.currentThread( )를 통해 현재 쓰레드 객체 참좃값을 얻어올 수 있다.

• activeCount( )

: 현재 실행 중인 쓰레드의 개수를 알 수 있다.

public class ThreadExample05 {
    public static void main(String[] args) {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 실행 중");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 종료");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 2 실행 중");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2 종료");
            }
        });

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 3 실행 중");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 3 종료");
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

System.out.println("현재 활성 스레드 수: " + Thread.activeCount());

main 쓰레드 내에는 총 3개의 쓰레드가 동작하고 있다. 이렇게 같은 그룹 내에서 실행 중인 쓰레드의 개수를 알고싶을 때 activeCount를 사용한다.

• setName( )

: 쓰레드에 직접 이름을 부여한다.

Thread t1 = new Thread(task);
Thread t2 = new Thread(task);

t1.setName("1번");
t2.setName("2번");

• getName( )

: 직접 지정했거나 자동으로 부여된 쓰레드의 이름을 가져온다.

for(int i=0; i<3; i++){
    Thread t1 = new Thread();
    t1.setName(i + "번째 쓰레드");
    System.out.println(t1.getName());
    t1.start();
}

• 우선순위

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

void setPriority(int priority)
int getPriority()

모든 쓰레드는 1~10 사이의 우선 순위를 가지고 있다. 1이 가장 낮은 순위이며 10이 가장 높은 순위다. 우선순위를 지정하지 않으면 기본값으로 5의 우선순위를 갖는다. 우선순위는 쓰레드의 동시성과 관계가 있다. 만일 2개의 작업이 일정 시간 간격으로 번갈아가면서 실행할 경우 우선순위가 더 높은 쪽이 상대적으로 많은 시간을 할당받게 된다.

setPriority( )는 우선순위를 정할 때 사용하는 메서드고, getPriority( )는 지정된 우선순위 값을 가져오는 메서드다.

• availableProcessors

: 현재 컴퓨터의 CPU 코어 수를 알고 싶을 때 사용한다.

public native int availableProcessors();

✔️  데몬 설정_ 533p

• 데몬 쓰레드

: 일반 쓰레드가 모두 종료되면 함께 종료되는 쓰레드

Thread t1 = new MyThread();
t1.setDeamon(false);
t1.setName("t1");
t1.start();

Thread t2 = new MyThread();
t2.setDeamon(true);
t2.setName("t2");
t2.start();

try{Thread.sleep(3500);} catch (InterruptedException e) {}
System.out.println("main Thread 종료");

쓰레드의 데몬 설정은 Thread 클래스의 인스턴스 메서드인 setDeamon( )메서드를 사용한다. 이때 기본 값은 false로 일반 쓰레드로 설정해둔다. 생성한 객체의 데몬 설정 여부는 isDeamon( )메서드를 사용해 언제든지 확인할 수 있다. 위의 코드에선 쓰레드 t1은 일반 쓰레드, t2는 데몬 쓰레드로 설정했다.

데몬 설정은 반드시 쓰레드를 실행하기 전인 start( ) 메서드 호출 전에 설정해야 한다. 쓰레드가 실행되고가면 데몬 설정은 바꿀 수 없게 된다. 

만약 main에 일반 쓰레드 t1과 데몬 쓰레드 t2가 있다고 가정해보자. 데몬 쓰레드는 자신을 호출한 main 쓰레드가 종료되면 함께 종료될거라 예상하겠지만 데몬쓰레드는 주 쓰레드의 종료가 아닌 프로세스 내의 모든 일반 쓰레드가 종료되어야 종료된다는 것을 알아야한다. main이 먼저 끝내도 t1 쓰레드가 종료되지 않은 상태라면 t2는 여전히 작동하고 있을 것이다.

📚 참고한 책

- 기본적인 개념을 정리하고 추가적으로 궁금한 것들을 정리했습니다 -

🐥 🐥 🐥

✔️   예외처리_ 467p

• try

: 예외가 발생할 수 있는 코드가 포함되어있다.

• catch

: 예외가 발생했을 때 처리할 코드가 포함된다.

• finally

: 예외가 발생하든, 발생하지 않든 항상 실행되는 블록으로, 일반적으로 리소스 해제나 try{ }, catch{ }의 공통 기능 코드가 포함되어있다.

try {
    int a = 10 / 0;
}

catch (Exception e) {
    System.out.println("예외 발생!");
}

catch (ArithmeticException e) {
    System.out.println("0으로 나눌 수 없습니다!");
}

finally {
    System.out.println("프로그램 종류");
}

try는 예외가 발생할 수 있는 코드를 담고 있다. 해당 코드에선 ArithmeticException이란 예외를 발생시킨다. catch는 예외를 처리하는 방식을 나타내는데 여러 개를 정의할 수 있다. try에서 예외가 발생하면 그에 맞는 처리방법을 찾기 위해 첫번째 catch부터 finally를 향해 내려간다.

그런데 위의 코드는 예외를 처리하는 과정에서 오류가 발생한다. 모든 예외는 Exception 클래스의 하위 클래스로 어떤 예외가 발생하든 첫번째 catch 블록만 실행되므로 두번째 catch 블록에 도달할 수 없는 코드가 된다. 그래서 unreachable code 오류가 발생한다.

try {
    int a = 10 / 0;
}

catch (ArithmeticException e) {
    System.out.println("0으로 나눌 수 없습니다!");
}

catch (Exception e) {
    System.out.println("예외 발생!");
}

finally {
    System.out.println("프로그램 종류");
}

순서를 바꿔주면 오류가 해결되어 예외 처리가 가능해진다.

• 다중 예외 처리

public class TryCatchPratice1 {
    public static void main(String[] args) {
    
        try {
            System.out.println(10 / 0); 
        } catch (ArithmeticException e) {
            System.out.println("0으로 나눌 수 없습니다.");
        } finally {
            System.out.println("프로그램을 종류합니다.");
        }    

        try {
            int[] arr = new int[3];
            System.out.println(arr[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("배열 인덱스 범위를 벗어났습니다.");
        } finally {
            System.out.println("프로그램을 종류합니다.");
        }    
    }
}

첫번째 try에서는 0으로 나누는 것이 불가능하여 ArithmeticException 예외 처리방법을 뒀다. 두번째 try에서는 배열의 크기가 3임에도 그 이상에 있는 배열을 출력시키며 발생한 인덱스 범위 오류 예외를 처리했다. finally의 경우 중복되어 코드를 작성했다.

public class TryCatchPratice02 {
    public static void main(String[] args) {
        try {
            int[] arr = new int[3];
            System.out.println(10 / 0);     
            System.out.println(arr[5]);      
        } catch (ArithmeticException e) {
            System.out.println("0으로 나눌 수 없습니다.");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("배열 인덱스 범위를 벗어났습니다.");
        } finally {
            System.out.println("프로그램을 종류합니다.");
        }    
    }
}

하나의 try 블록 안에 여러 예외를 넣고 catch로 예외처리를 한다. 이렇게 하면 훨씬 간결한 코드가 완성된다. try 블록에 있는 예외 코드는 catch 블록의 순서와 연관없이 알아서 작성해주면 된다. try와 catch에 중복된 코드가 있을 경우, finally에 적어 중복을 피할 수 있다.

• 다중 예외를 한 블록에서 처리하는 방법

public class TryCatchPratice02 {
    public static void main(String[] args) {
        try {
            int[] arr = new int[3];
            System.out.println(10 / 0);     
            System.out.println(arr[5]);      
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("예외가 발생했습니다.");
        } finally {
            System.out.println("프로그램을 종류합니다.");
        }    
    }
}

하나의 catch 블록에서 두 개의 예외를 처리할 수 있다. 그럴 경우 |(OR)을 사용하여 나타내면 된다.

✔️   리소스 해제_ 477p

• 리소스 해제

: 더이상 사용하지 않는 자원을 반납하는 것을 의미한다.

• InputStreamReader를 이용하여 리소스 자동 해제

try (InputStreamReader isr1 = new InputStreamReader (System.in);) {
    char input = (char) isr1.read();
    System.out.println("입력 글자 = " + input);
} catch (IOException e) {
    e.printStackTrace();
}

try (InputStreamReader isr2 = new InputStreamReader (System.in);) {
    char input = (char) isr2.read();
    System.out.println("입력 글자 = " + input);
} catch (IOException e) {
    e.printStackTrace();
}

InputStreamReader에는 AutoCloseable을 구현하고 있다. try의 괄호 안에 선언된 객체가 예외 처리 구문의 실행이 끝나면 자동으로 close( ) 호출해 리소스를 해제한다. 

그런데 위의 코드는 첫번째 try 블록에서 예외처리를 마치고 리소스를 해제했다. 그러면 그 다음 try 블록은 어떻게 진행되는걸까. System.in은 콘솔 입력을 처리하는 리소스로 자바 가상 머신이 단 하나의 객체를 생성해 제공하기 때문에 이를 반납하면 더이상 콘솔을 입력할 수 없게된다. 그러므로 첫번째 try 블록에서 리소스를 반납해서 다음 try 블록은 사용할 수 없게된다.

• 직접 close를 설정하여 리소스 수동 해제

A a1 = null;

try {
    a1 = new A("특정 파일")
}

catch (Exception e) {
    System.out.println("예외 처리");
}

finally {
    if(a1.resource!=null) {
        try{
            a1.close();
        } catch (Exception e) {
        }
    }
}

finally에 직접 close( )를 정의한다. finally에 정의하지 않는다면, 클래스 A에 AutoCloseable 인터페이스를 구현한다. AutoCloseable 내부에 close( ) 메서드를 포함하고 있기에 finally에 직접 정의하지 않아도, 리소스를 알아서 해제할 것이다.

✔️   예외전가_ 485p

• 예외 전가

: 예외 처리의 의무를 호출한 메서드가 예외를 갖게 되며, 상위의 메서드도 자신을 호출한 지점으로 예외를 전가할 수 있다.

• throws

: 예외 전가 문법이다.

    public static void readFile() throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
        String line = reader.readLine();
        System.out.println("읽은 내용: " + line);
        reader.close();
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("파일을 읽는 중 오류 발생: " + e.getMessage());
        }
    }

readFile 메서드에서 발생하는 예외를 IOException으로 전가되었으며 메서드 내부에서 try-catch 구문으로 처리하지 않았다. 대신, main 메서드에서 readFile( )을 호출할 때  try-catch로 예외를 처리한다. 예외 전가는 위의 코드처럼 예외를 유연하게 분리 시켜 나중에 처리하도록 해준다.

예외를 처리하지 않고 계속 전가하게 되면 자바 가상 머신이 직접 예외를 처리하게 된다. 자바 가상 머신의 예외 처리 방법은 우리가 잘 아는 방법이다. 발생한 예외의 정보를 화면에 출력한 뒤 프로그램을 강제 종료하는 것이다.

예외 전가도 다중으로 처리 가능하다. throws 예외 클래스 A, 예외 클래스 B... 로 한 번에 전가하면 된다.

✔️   사용자 정의 예외 클래스_ 492p

• 사용자 정의 예외 클래스

: 자바에 존재 하지 않는 예외를 직접 작성한다.

• 사용자 정의 예외 클래스 작성

public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

생성자에서 message를 받아, 예외 메시지를 부모에게 전달한다.

• 사용자 정의 예외 객체 생성과 예외 객체 던지기

throw new MyException("나이가 너무 어려서 가입할 수 없습니다.");

• 사용자 정의 예외 객체 생성과 예외 객체 던지기

public class Pratice01 {

    public static void checkAge(int age) throws MyException {
        if (age < 18) {
            throw new MyException("나이가 너무 어려서 가입할 수 없습니다.");
        } else {
            System.out.println("가입이 가능합니다.");
        }
    }

    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (MyException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }
}

18살 이하면 MyException 예외가 발생하도록 만들었다. try 블록에서 15를 인자로 보냈고 예외 MyException이 발생해 예외를 던졌다. catch 구문에서 받아 예외 발생 문구를 출력한다.

✔️   예외 클래스의 메서드_ 497p

• getMassage( ) 메서드

: 예외가 발생했을 때 생성자로 넘긴 메시지를 문자열 형태로 리턴하는 메서드

 throw new MyException("나이가 너무 어려서 가입할 수 없습니다.");

System.out.println("예외 발생: " + e.getMessage());

나이가 너무 어려서 예외가 발생했다. 예외는 "나이가 너무 어려서 가입할 수 없습니다."라는 메시지를 포함하고 있다. 해당 메시지는 예외 객체를 생성할 때 입력매개변수로 전달된다. 이 문자열은 getMassage( ) 메서드를 통해 리턴한다.

• printStackTrace( ) 메서드

: 예외 발생이 전달되는 경로로, 예외 발생 시 개발자가 디버깅할 수 있도록 예외의 원인을 자세히 출력한다.

try (InputStreamReader isr1 = new InputStreamReader(System.in)) {
    char input = (char) isr1.read();
    System.out.println("입력 글자 = " + input);
} catch (IOException e) {
    e.printStackTrace();
}

콘솔에 예외가 어디에서 전가되었는지 등 추적 정보를 출력한다.