liy_se00.log

[자바웹개발 워크북] 2. 웹과 데이터베이스

Fri, 18 Jul 2025 10:07:46 GMT

2.1 JDBC 프로그래밍 준비

DB 종류: MSSQL, MySQL, MariaDB, Postgresql, Oracle DB.... 이 책에서는 MariaDB를 사용합니다.

mariadb의 포트 설정 부분에서 3306으로 기본 설정이 되어있는데, 나는 워낙 컴퓨터에 깔려있는게 많으므로 3306포트를 사용하고있는 db가 있는지 확인해주었다.

터미널에서 조회해보니, MySQL 서버가 점유 중이라고 뜬다.

따라서, mariadb는 3307로 설정해주었다.

public class ConnectTest {

    @Test
    public void testConnection() throws Exception {

        Class.forName("org.mariadb.jdbc.Driver");

        Connection connection = DriverManager.getConnection(
            "jdbc:mariadb://localhost:3307/webdb",
            "webuser",
            "webuser");

        Assertions.assertNotNull(connection);

        connection.close();
    }
}

[자바웹개발 워크북] 1. 웹 프로그래밍의 시작

Thu, 10 Jul 2025 10:27:35 GMT

1.1 자바 웹 개발 환경 만들기 1.2 웹 기본 동작 방식 이해하기 1.3 Web MVC 방식 1.4 HttpServlet 1.5 모델(Model)

1.1 자바 웹 개발 환경 만들기

📌JSP(Java Server Page)

JSP 파일은 Java Server Pages의 약자로, 동적인 웹 페이지를 만들기 위해 HTML 코드 내에 Java 코드를 삽입하여 사용하는 기술입니다.
JSP 활용 시 <% %>를 사용하면 HTML문서 중간에 Java코드를 삽입하여 동적인 코드로 변경이 가능

1.2 웹 기본 동작 방식 이해하기

🔸브라우저와 서버의 관계 이해 🔸서블릿과 JSP가 브라우저에 데이터를 전달하는 과정, 🔸브라우저에서 사용되는 과정

📌 Request(요청)/Response(응답)

브라우저에 원하는 정보를 전달하는 방식 GET, POST

GET 주소와 필요한 데이터를 한번에 같이 보내기 때문에 단순 링크로 처리된다. ex) https://velog.io/@liy_se00/posts?tag=000000

POST 주소와 데이터를 따로 보내는 방식. ex) /api/members/news/{newsId}/read

✨브라우저와 서버의 데이터 전달 과정

브라우저에서 데이터를 요구 = 요청(Request)
서버는 이에 대한 응답(Response) 데이터를 만들어 브라우저로 보낸다.
서버에서는 이를 정적인 데이터인지 동적인 데이터인지에 따라 다르게 처리.

웹 서버(Web Server): 항상 같은 정적 데이터만 보내는 역할만을 수행하는 서버
웹 애플리케이션 서버(Web Application Server; WAS): 동적 데이터를 만들어 보내는 경우의 서버. 대부분의 WAS는 웹 서버 기능도 같이 포함하므로 이미지, CSS/JS, 서블릿/JSP 모두 처리 가능.

📌 HTTP(Hyper Text Transfer Protocol)

✨프로토콜(protocol) : 브라우저의 요청과 서버의 응답 사이에서 한 데이터 교환 약속. 웹에서는 HTTP나 보안이 강화된 프로토콜인 HTTPS 프로토콜 방식으로 데이터를 주고받는다.

개발자도구 -> Network -> 오가는 데이터 확인 가능(Headers, Response, Cookies...)

✨비연결성(Connectionless) 웹의 특성상 여러 사용자가 브라우저를 통해 서버를 호출하는 구조이기 때문에 서버에서는 최대한 많은 사용자에게 서비스를 제공하기 위한 고민이 필요하다. -> HTTP는 이를 위해 '비연결성' 방식을 택하는데, 이는 요청과 응답을 처리한 후 연결을 종료하는 것이다. ex) 새로고침

📌 자바 서버 사이드 프로그래밍

서버 사이드 프로그래밍: 서버 쪽에서 프로그래밍을 통해 데이터를 처리할 수 있도록 구성하는 것을 의미

동시에 여러 요청 어떻게 처리?
서버 문제 발생 시 어떻게 처리?
어떤 방식으로 데이터 전송 최적화?
분산 환경이나 분산 처리 문제?

자바의 경우 위와 같은 처리를 JavaEE라는 기술 스펙으로 정리해 두었고, Servlet과 JSP는 JavaEE의 여러 기술 중 가장 기본적인 기술이다.

[ Servlet ]

✨서블릿(Servlet) 기술 서버에서 동적으로 요청과 응답을 처리할 수 있는 API들을 정의한 것

🔸톰캣이란(Tomcat)? 톰캣은 아파치 소프트웨어 재단의 웹 어플리케이션 서버(와스)로서, 자바 서블릿을 실행키고 JSP코드가 포함되어 있는 웹 페이지를 만들어준다. 출처: https://cheershennah.tistory.com/54

JSP는 근본적으로 서블릿과 같은 원리이지만 좀 더 HTML을 쉽게 이용할 수 있는 방식으로 코드를 작성할 수 있기 때문에 '서블릿으로는 코드를 이용한 처리, JSP로는 화면 개발'과 같이 역할을 분담해서 개발하는 것이 일반적이다.

서블릿 컨테이너: 서블릿의 실행은 서블릿을 실행할 수 있는 환경에서 실행이 가능하다.(톰캣) 이를 '서블릿 컨테이너'라 부르며 과거에는 '서블릿 엔진'이라고 불렀다.

서블릿 코드를 실행하는 주체는 서블릿 컨테이너(톰캣)이므로, 일반 자바 프로그램과 아래와 같은 점들이 달라진다.

객체 생성, 호출 주체는 서블릿 컨테이너
객체의 관리 자체가 서블릿 컨테이너에 의해 관리
서블릿/JSP 코드 개발은 기본적인 자바 API와 더불어 서블릿 API도 같이 사용해야 한다. ex) 서블릿 클래스를 보면 import에 javax로 시작하는 서블릿 관련 API가 java.io.*와 함께 사용된 것을 볼 수 있다.

서블릿 라이프 사이클: init(), doGet(), destory()등 서블릿 API에서 지정된 메소드들을 서블릿 컨테이너가 호출하고 관리하는 것

[ JSP ]

✨ JSP 기술 서블릿이 있는데도 JSP가 제공되는 이유? 👉🏻 두 기술의 목적 자체가 다르기 때문

JSP 기술은 서블릿과 달리 HTML 코드를 그대로 이요하고 필요할 때 약간의 자바 코드를 넣음
서블릿은 자바 코드를 이용해여 HTML 문자열을 만들어내는 방식의 차이

JSP 파일도 서블릿 코드로 변환되어 컴파일되고 실행된다. JSP 파일은 필요한 순간에 자바 파일로 생성되고, 컴파일하여 class 파일로도 만들어진다. HTML 코드 -> 모두 out.write("\n"); 형태의 코드로 변환된다.

🔸서블릿/JSP 공통점

모두 JavaEE 스팩의 일부
실행하기 위해서 서블릿 컨테이너가 필요함
서블릿 컨테이너가 객체를 생성하고 생명주기 관리

✨JSP 특징

${}: JSP에서 사용하는 EL 기술. 서버에서 데이터를 출력하는 용도
웹의 파라미터는 모두 문자열 -> 숫자 계산을 위해서는 Integer.parseInt() 적용
JSP는 기본적으로 GET/POST 방식의 호출을 구분하지 않는다.

JSP 올바른 사용법

JSP에서 쿼리 스트링이나 파라미터를 처리하지 않는다. 👉🏻 JSP 대신 서블릿으로 처리
입력 화면을 구성하거나 처리 결과를 보여주는 용으로만 사용
서블릿 경로를 통해 JSP를 보는 방식으로 사용
JSP는 직접 호출하지 않고 Controller를 통해서만 JSP에 접근하도록 구성
JSP는 결과만/처리는 서블릿

-> 이러한 문제를 해결하기 위해 등장한 것이 웹 MVC

1.3 Web MVC 방식

- MVC 구조와 서블릿/JSP

요청이 들어오면 -> 서블릿은 준비한 데이터를 JSP로 전달 -> JSP는 EL을 이용해 최종적인 결과 데이터 생성 -> 생성된 결과 화면은 톰캣을 통해 브라우저로 전송

📌 웹 MVC 구조

: Model - View - Controller 역할을 분리해서 처리하는 구조

Controller: 데이터 처리(서블릿)
View: 결과 처리(JSP)
Model: JSP에 필요한 데이터를 가공하는 역할을 하는데 필요한 데이터를 제공하는 객체

- RequestDispatcher를 이용한 요청(Request) 배포

@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
        ServletException, IOException {
        System.out.println("InputController...doGet...");
        RequestDispatcher dispatcher = req.getRequestDispatcher("/WEB-INF/calc/input.jsp");
        dispatcher.forward(req, resp);
    }

👉🏻 WEB-INF 란? WEB-INF는 브라우저에서 직접 접근이 불가능한 특별한 경로입니다. WEB-INF 밑에 jsp 파일을 둔다는 것은 브라우저에서 jsp로 "직접" 호출이 불가능하다는 것을 의미합니다.(따라서 jsp 파일이 호출될 때는 controller를 필수적으로 거치게 됩니다.)

✨RequestDispatcher

서블릿에 전달된 요청을 다른 쪽으로 전달 혹은 배포한다.
RequestDispatcher를 이용하면 InputController는 jsp파일로 가는 중간 경유지가 됩니다.

✨** reponse.sendRedirect("/....") **

POST 방식으로 처리하고 JSP를 이용해서 결과를 보여주는 방식을 이용할 때 HttpServletResponse의 sendRedirect()로 처리가 끝난 후에 다른 경로로 이동하게 하는 것이 일반적이다.

📌 PRG 패턴(Post-Redirect-GET)

PRG 패턴은 POST 방식의 처리 후에 바로 다른 주소로 브라우저가 이동하기 때문에 반복적으로 POST 호출이 되는 상황을 막을 수도 있습니다.

웹 MVC 구조에서 가장 흔하게 사용하는 패턴
사용자는 컨트롤러에 원하는 작업을 POST 방식으로 처리하기를 요청
POST 방식을 컨트롤러에서 처리 -> 브라우저는 다른 경로로 이동(GET)하라는 응답(Redirect)
브라우저는 GET 방식으로 이동

1.4 HttpServlet

Servlet 클래스의 상속 구조

HttpSevletRequest의 주요 기능

주로 '읽는' 기능 제공

🔹 getParameter()

?name=AAA&age=20과 같은 쿼리 스트링에서 키를 이용해 값을 얻을 때 사용
getParameter() 결과값은 항상 String
문자열로 반환되기 때문에 숫자를 처리할 때의 예외 발생을 주의해야 한다.
해당 파라미터가 존재하지 않는다면 null 반환 주의

🔹 getParameterValues()

동일한 이름의 파라미터가 여러 개 있는 경우에 사용
String[] 타입으로 반환

🔹 setAttribute()

JSP로 전달할 데이터를 추가할 때 사용한다.
key와 value의 형태로 데이터를 저장할 수 있다.

🔹 RequestDispatcher

현재의 요청을 다른 서버의 자원에게 전달하는 용도로 사용
forward() : 현재까지의 모든 응답 내용은 무시하고 JSP가 작성하는 내용만을 브라우저로 전달

HttpSevletResponse의 주요 기능

주로 '쓰는' 기능 제공

웹 MVC 구조에서 주로 JSP에서 처리되기 때문에 sendRedirect()를 이용하는 경우가 많다.

1.5 모델(Model)

모델과 3티어

DTO(Data Transfer Object)

3티어와 같이 계층을 분리하는 경우에는 반드시 계층이나 객체들 간에 데이터 교환이 이루어지기 때문에 여러 개의 데이터를 묶어서 하나의 객체로 전달하는 것을 DTO라고 한다.

대부분 Java Beans 형태로 구성한다.

Java Beans 구성
생성자가 없거나
반드시 파라미터가 없는 생성자 함수를 가지는 형태
속성은 private으로 작성
getter/setter 제공
추가 선택적 규칙) Serializable 인터페이스 구현해야 함

public enum TodoService {

    INSTANCE;
}

enum 타입으로 클래스를 작성하는 경우, 정해진 수만큼만 객체를 생성할 수 있다는 장점이 있다. TodoService.INSTANCE와 같이 간단하게 객체를 하나만 생성해서 사용 가능하다. 이를 싱글톤 패턴이라고 한다.

싱글톤 패턴? 왜 싱글톤 패턴을 사용할까?
- 인스턴스가 하나만 필요할 때 예를 들어, 설정 정보(환경 설정 클래스), 로깅 클래스, DB 커넥션 풀 관리 클래스 등은 여러 개의 객체가 필요하지 않다.
- 메모리 낭비 방지 매번 new 키워드로 객체를 생성하지 않고 하나의 인스턴스를 재사용함으로써 메모리를 절약할 수 있다.
- 전역 접근 어디서든지 동일한 인스턴스를 사용할 수 있어, 공유 리소스 관리에 유용하다.
enum class로 INSTANCE를 만든 이유는 Java의 Enum이 JVM 차원에서 싱글톤을 보장하기 때문

[Spring MVC] 3. HttpServletRequest/Response

Sun, 06 Apr 2025 10:02:43 GMT

이 글은 김영한 강의 - Spring MVC 1편 섹션3.서블릿 강의를 듣고 정리한 글입니다.

📍HttpServletRequest

서블릿은 개발자가 HTTP 요청 메시지를 편리하게 사용할 수 있도록 개발자 대신에 HTTP 요청 메시지를 파싱한다. 그리고 그 결과를 HttpServletRequest 객체에 담아서 제공한다.

🔑중요 HttpServletRequest, HttpServletResponse를 사용할 때 가장 중요한 점은 이 객체들이 HTTP 요청 메시지, HTTP 응답 메시지를 편리하게 사용하도록 도와주는 객체라는 점이다. 따라서 이 기능에 대해서 깊이있는 이해를 하려면 HTTP 스펙이 제공하는 요청, 응답 메시지 자체를 이해해야 한다.

HttpServletRequest를 사용하면 Http 요청 메세지를 편리하게 조회 가능하다.

POST /save HTTP/1.1
Host: localhost:8080
Content-Type: application/x-www-form-urlencoded

username=kim&age=20

START LINE(HTTP 메소드, URL, 쿼리스트링, 스키마, 프로토콜), 헤더, 바디

임시 저장소 기능
세션(로그인) 관리 기능

⭐ 주로 3가지 방법의 Http 요청

GET - 쿼리 피라미터 POST - HTML Form HTTP message body

GET - 쿼리 피라미터
- 메세지 바디 없이 URL의 쿼리파라미터를 사용해서 데이터 전달 예) 검색, 필터, 페이징 등에서 많이 사용함
- 복수 파라미터에서 단일 파라미터 조회? username=hello&username=kim과 같이 파라미터 이름은 하나, 값이 중복일 경우 -> 이렇게 거의 안쓰긴 함. -> 쓴다면 request.getParameterValues()를 사용해야 한다. -> request.getParameter()는 하나의 파라미터 이름에 단 하나의 값만 있을 때 사용 (여러개일 경우 첫번째 값만 반환한다)

POST - HTML Form
- 메세지 바디에 쿼리 파라미터 형식으로 전달: username=hello&age=20
  - 예) 회원가입, 상품주문, HTML Form 사용
- Content-Type은 HTTP message body가 어떤 형식의 데이터인지 알려준다(GET URL 쿼리 파라미터 형식은 content-type이 null이다.)
- Content-Type: application/x-www-form-urlencoded
- message body : username=kim&age=20
- 클라이언트 입장에서는 두 방식에 차이가 있지만, 서버 입장에서는 둘의 형식이 동일하므로, HTML Form 같은 경우도 request.getParameter()로 구분 없이 조회할 수 있다.
- Form 데이터를 Body로 전송할 때는 POST방식만 허용됨

HTTP message body
- Http API에서 주로 사용 (JSON, ~~XML, TEXT~~) : HTTP message body에 데이터를 직접 담아서 요청
  - POST, PUT PATCH
- JSON 형식으로 전송할 때 (실습)
  - POST http://localhost:8080/request-body-json
  - content-type : application/json
  - message body : {"username": "hello", "age": 20}

📍HttpServletResponse

HttpServletResponse의 역할

응답은 크게 3가지 단순 text 보내는 것 html 보내는 것 body에 직접 json 보내는 것

HTTP 응답 메세지 생성

HTTP 응답코드 지정 (200, 400, 404, 500...)
헤더 생성
바디 생성

+) 편의 기능 제공(Content-Type, 쿠키, Redirect)

@WebServlet(name = "responseHtmlServlet", urlPatterns = "/response-html")
public class ResponseHtmlServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // Content-Type: text/html;charset=utf-8
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");

        PrintWriter write = response.getWriter();
        write.println("");
        write.println("");
        write.println("     안녕! ");
        write.println("");
        write.println("");
    }
}

http 응답으로 HTML을 반환할 때는 content-type을 text/html로 지정해야 한다.

[Spring MVC] 2. SSR&CSR

Thu, 03 Apr 2025 06:20:01 GMT

이 세가지를 어떻게 제공할까를 고민해야 한다.

정적 리소스
동적 HTML 페이지
HTTP API

정적 리소스 : 웹브라우저-Web Server-리소스파일-웹브라우저
HTML 페이지 : 웹브라우저-WAS-HTML-웹브라우저
HTTP API : HTML이 아니라 데이터를 전달(주로 JSON형식) (웹브라우저-WAS-DATA-웹브라우저)
1. 데이터만 주고받고, UI화면이 필요하면 클라이언트가 별도로 처리
2. 다양한 시스템에서 연동
3. UI 클라이언트 접점
  - 앱 클라이언트
  - 웹 브라우저에서 JS를 통한 HTTP API 호출
  - React, Vue.js 같은 웹 클라이언트
4. 서버 to 서버
  - 주문 서버 -> 결제 서버
  - 기업 간 데이터 통신

SSR, CSR

서버 사이드 랜더링, 클라이언트 사이드 랜더링

SSR - 서버 사이드 랜더링

서버에서 최종 HTML을 생성해서 클라이언트에 전달 DB조회, 최종 HTML 만드는 것을 모두 서버에서 함 웹 브라우저는 다 만들어진 것을 띄우기만 함

툴: ~~JSP~~, 타임리프(필수) -> 백엔드 개발자 타임리프 - 화면이 정적이고, 복잡하지 않을 때

Ex)

정적 성격이 강한 페이지 (에러 페이지, 로그인 페이지) 는 백엔드 SSR로 빠르게 처리
kakao 로그인/회원가입/인증 페이지는 서버 사이드 렌더링(SSR) 방식 사용 이유: 빠른 초기 응답, SEO 대응, 보안 이유 등
배달의 민족 배달 가게 사장님용 관리자 페이지(사장님 사이트) 일부 이유: 특정 기능은 빠른 접근성과 관리 편의성이 중요해서 SSR로 처리 그리고 관리자 페이지는 SEO나 초기 로딩 속도가 중요한 경우가 많음
기업 내부 시스템 대부분의 대기업, 공공기관 백오피스는 하이브리드 방식 📌 사내 시스템이라 UX보다 개발 속도, 안정성, 배포 간소화를 중요하게 여김

CSR - 클라이언트 사이드 랜더링

HTML 결과를 JS를 사용해 웹 브라우저에서 동적으로 생성해서 사용 웹 환경을 마치 앱처럼 필요한 부분부분 변결 가능 Ex) 구글지도, Gmail, 구글 캘린더

툴: React, Vue.js -> 웹 프론트엔드 개발자

HTML 요청(/orders.html) - js링크를 내려줌
js 코드 요청 - 서버에서 응답
HTTP API - 데이터 요청(JSON)
웹 브라우저에서 js로 HTML 결과 랜더링

[Spring MVC] 1. Servlet&Thread

Thu, 03 Apr 2025 05:18:54 GMT

서블릿(Servlet)

개발자가 비즈니스 로직만 작성할 수 있게 나머지 단계를 자동화해준다.

@WebServlet(name="helloServlet", urlPatterns="/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) {
    }
}

HTTP 요청 정보를 편리하게 사용할 수 있는 HttpServletRequest HTTP 응답 정보를 편리하게 사용할 수 있는 HttpServletResponse

📍Servlet HTTP 요청, 응답 흐름

HTTP 요청시

WAS는 Request, Response 객체를 새로 만들어서
서블릿 객체 호출
개발자는 Request 객체에서 HTTP 요청 정보 편리하게 꺼내서 사용
Response 객체에서 HTTP 응답 정보 편하게 입력
WAS는 Response 객체에 담겨있는 내용으로 HTTP 응답 정보 생성
웹 브라우저에 전송
웹 브라우저가 html 랜더링해서 화면에 띄움

Servlet Container

서블릿을 지원해주는 WAS = 서블릿 컨테이너

서블릿 객체를 서블릿 컨테이너가 자동으로 생성해준다.
서블릿 객체 생성, 초기화, 호출, 종료등 생명주기도 관리해줌
서블릿 객체는 싱글톤으로 관리
- 싱글톤: 객체를 하나만 생성해놓고 하나를 모두가 공유해서 쓰는 것
- response, request 객체는 요청마다 다 다르게 새로 만들어짐.
- 그러나 helloServlet이라는 것은 다시 만들 필요가 없음
- 그래서 최초 로딩 시점에 서블릿 객체를 미리 만들어두고 재활용
- 모든 고객 요청은 동일한 서블릿 객체 인스턴스에 접근
- 공유변수(멤버변수) 사용 주의
- 서블릿 컨테이너 종료시 함께 종료
JSP도 서블릿으로 변환되어 사용
동시 요청을 위한 멀티 쓰레드 처리 지원
- WAS가 멀티쓰레드 자동으로 처리해줌

📍동시 요청 - 멀티 쓰레드

웹 브라우저가 WAS에 요청을 하면 서블릿 호출. 서블릿이라는 것을 도대체 누가 호출하느냐?? -> 쓰레드!

쓰레드

애플리케이션 코드를 하나하나 순차적으로 실행하는 것이 쓰레드
자바 main 메서드 처음 실행 -> main이라는 이름의 쓰레드가 실행

단일 쓰레드?

-> 요청이 여러개 오면 모두 time out
요청마다 쓰레드 생성?
- 쓰레드는 생성 비용이 매우 비쌈
- 요청 올 때마다 생성하면 응답 속도 늦어짐
- 쓰레드 간 전환(컨텍스트 스위칭)에 비용 발생
- 쓰레드 생성에 제한이 없어진다.
- 고객 요청이 너무 많이 오면, CPU 메모리 임계점을 넘어 서버 죽음.
✅ 쓰레드 풀!

풀 안에 미리 갯수 제한하여 만들어놓음 쓰레드 다 쓰면 다시 풀에 반납 쓰레드 풀에 0개이면 쓰레드 대기, 거절

장점 - 필요한 쓰레드를 쓰레드 풀에 보관, 관리 - 쓰레드 풀에 생성 가능한 쓰레드의 최대치를 관리. - 톰캣은 최대 200개 기본 설정 - CPU 절약되고, 응답 시간이 빠름 - 최대치가 정해져있으므로 많은 요청이 들어와도 안전하게 처리 가능

⭐실무 Tip

최대 쓰레드(Max thread)를 튜닝했을때 극적인 효과를 볼 확률이 높음

👉🏻 최대 쓰레드 값이 너무 낮으면? - 서버 리소스는 여유롭지만, 클라이언트는 금방 응답 지연

👉🏻 최대 쓰레드 값이 너무 높으면? - 동시 요청이 많으면 CPU, 메모리 리소스 임계점 초과로 서버 다운

✅ 클라우드? -> 서버 늘리고 이후에 튜닝, 아니면 그냥 열심히 튜닝 ✅ 적정 숫자? -> 애플리케이션 로직의 복잡도, CPU, 메모리 상황에 따라 다름.

-> 최대한 실제 서비스와 유사하게 성능 테스트 (툴:아파치, nGrinder, 제이미터) -> 부하 테스트로 TPS(Transaction Per Second)를 측정한 뒤, 적정 스레드 수를 설정

규모	예상 maxThreads
소규모 서비스	100~200
일반 사용자 대상 중규모 서비스	200~500
트래픽 많은 대규모 서비스 (배달의 민족, 쿠팡 등)	400~1000 (하지만 여러 서버로 분산)

🔑 WAS의 멀티 쓰레드 지원

멀티쓰레드에 대한 부분은 WAS가 처리 개발자는 멀티 쓰레드 관련 코드를 신경쓰지 않아도 됨 개발자는 마치 싱글 쓰레드 프로그래밍을 하듯이 편리하게 소스코드 개발 멀티 쓰레드 환경이므로 싱글톤 객체(서블릿, 스프링 빈)는 주의해서 사용 -> 싱글톤 객체에 멀티 쓰레드(쓰레드 여러 개)의 호출이 들어옴 -> 멤버변수이기 때문에 주의 필요

[Git] 깃 명령어 정리

Mon, 23 Dec 2024 16:45:52 GMT

- 새 브랜치 만들기

$ git checkout -b feature-week1

-b 플래그는 현재 작업 중인 브랜치에서 새 브랜치를 생성해준다. 새 브랜치의 커밋 히스토리는 작업하고 있던 브랜치의 마지막 커밋에서 시작된다.

- fetch

git fetch origin의 주요 기능

$ git fetch origin

원격 브랜치 업데이트 원격 저장소(origin)에 있는 브랜치와 관련된 최신 변경 사항(커밋)을 가져옵니다. 이때 가져온 변경 사항은 로컬의 원격 추적 브랜치(예: origin/main, origin/feature-week8)에 저장됩니다.

병합 없이 안전하게 동기화 fetch는 로컬 브랜치에 변경 사항을 바로 적용하지 않기 때문에, 작업 중인 로컬 브랜치를 보호하면서 원격 저장소와의 차이를 확인할 수 있습니다.

원격 브랜치 및 태그 정보 업데이트 원격 저장소에서 새로 추가되거나 삭제된 브랜치 및 태그 정보를 로컬로 동기화합니다.

- 브랜치 전환

$ git checkout main

- 브랜치 삭제

로컬 브랜치 삭제
```
$ git branch -d <로컬_브랜치_이름>
```
현재 작업중인 브랜치는 삭제 불가능 브랜치에 병합되지 않은 변경사항 및 푸시되지 않은 커밋이 있는 경우 삭제 불가능

로컬 브랜치 강제 삭제

$ git branch -D <로컬_브랜치_이름>

- pull 관련 git

⚠️ ERROR ⚠️

hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

로컬 저장소에 있는 프로젝트를 깃허브에 push하려 할 때, 이런 문구가 떴다.

메세지를 보니, 현재 로컬 브랜치(yoonseo)가 깃허브에 있는 동일한 브랜치(remote branch)보다 옛날 상태라서 깃헙을 보호하기 위해 푸시를 막은 것으로 보인다.

✅ 해결

push 전에 pull을 해서 프로젝트를 병합해주어야 한다. git push origin yoonseo
refusing to merge unrelated histories 이런 문구가 뜬다면
git pull origin 브런치명 --allow-unrelated-histories 위 명령 옵션은 서로 관련 없는(공통 조상이 없는) 두 브랜치의 Git 히스토리를 강제로 병합하려고 할 때 사용하는 명령어이다.

참고: 보통 Git은 병합하려는 두 브랜치가 같은 루트(commit)에서 시작된 경우에만 병합을 허용한다. 하지만 아래와 같은 상황에서는 서로 "unrelated"한 것으로 간주하고 병합을 거부한다.

💥 이런 경우! 1. 두 개의 독립적으로 시작된 Git 저장소를 병합하려고 할 때 2. 처음에 깃허브에서 README.md만 있는 상태에서 로컬저장소를 push하려고 할때 - GitHub: README 하나 있음 - 로컬: 다른 커밋 있음 → 서로 공통 히스토리 없음 → 병합 불가 3. 이전에 공유한 적 없는 브랜치를 병합할 때 - ex: 팀원이 만든 브랜치와 내 브랜치가 아예 다른 시작점에서 만들어짐

[UMC] 5주차. JPA 기초 및 프로젝트 구조

Wed, 30 Oct 2024 02:13:33 GMT

어노테이션 정리

domain 패키지 -> Member.java

@Entity
@Getter
@Builder
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class Member {

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

기본키를 만들 때 사용한 어노테이션 @GeneratedValue(strategy = GenerationType.IDENTITY) : JPA가 통신을 하는 DBMS의 방식을 따른다
@Entity : 어노테이션을 통해 해당 클래스가 JPA의 엔티티임을 명시 @Getter : lombok 제공. getter을 만들어주는 어노테이션
@Builder @NoArgsConstructor(access = AccessLevel.PROTECTED) @AllArgsConstructor : 위 세 개의 어노테이션은 자바의 디자인 패턴 중 하나인 빌더 패턴을 사용하기 위함. 빌더 패턴을 사용하면 생성자를 사용하는 것보다 더욱 편리하게 코당 가능.

@Getter, @Setter

[참고자료]: [OOP] Getter와 Setter는 지양하는게 좋다 by 개발하는 곰돌이 https://colabear754.tistory.com/173

@Getter와 @Setter의 사용 지양할 것.

Setter 대신 명확한 의도를 가진 메소드를 사용하라.
Getter로 조건을 검사하지 말고 결과를 반환하게 하라.

Ex) 출금의 경우, AccountService에서 계좌 잔액 충분한지 확인 -> 잔액 변경 (X) 그냥 Account에 출금할 금액을 전달 -> 출금 (O)

class Account {
   private long balance;

  public void withdraw(long amount) {
      if (amount > balance) {
          throw new IllegalArgumentException("잔액이 부족합니다.");
      }       
      balance -= amount;
  }
}

@Service public class AccountService { ...
public void withdraw(long id, long amount) { Account account = accountRepository.findById(id).orElseThrow(); account.withdraw(amount); } ... }

= 이렇게 하면 코드가 간결해짐과 동시에 의도도 명확해졌다.





## @Enumerated
---
❗**정해진 값들 중에서 특정 값이 저장되는 경우**,
Ex) gender, status, social_type
String 타입을 사용하기 보다는 **enum**을 사용하는 것이 좋다.

![](https://velog.velcdn.com/images/liy_se00/post/60f17283-9ae0-48f9-bfaf-a60a371fe2cf/image.png)

이때 EnumType은 반드시 **STRING** !!

ORDINAL 사용시 데이터베이스에 enum의 순서가 저장되는데,
만약 enum의 순서를 바꿀 경우 에러가 생김.


## Created_at, Updated_at
---

### @EnableJpaAuditing

❓ **JPA Auditing**(감시,감사)

데이터베이스에서 **누가, 언제** 하였는지 기록을 잘 남겨놓아야 합니다.
때문에 **생성일, 수정일 컬럼**이 대단히 중요합니다.
JPA에서 제공하는 기능인 `Audit`은 Spring Data JPA에서 **시간에 대해서 자동으로 값을 넣어주는 기능**입니다.

1. build.gradle
    `spring-boot-starter-data-jpa`만 추가해도 Audit을 하는데는 문제가 없습니다.

2. BaseTimeEntity.java
```java
@Getter
@MappedSuperclass 
@EntityListeners(AuditingEntityListener.class) 
public abstract class BaseTimeEntity{

    // Entity가 생성되어 저장될 때 시간이 자동 저장됩니다.
    @CreatedDate
    private LocalDateTime createdDate;

    // 조회한 Entity 값을 변경할 때 시간이 자동 저장됩니다.
    @LastModifiedDate
    private LocalDateTime modifiedDate;

}

Spring boot Application에 @EnableJpaAuditing추가

@SpringBootApplication
@EnableJpaAuditing
public class StudyApplication {

 public static void main(String[] args) {
     SpringApplication.run(StudyApplication.class, args);
 }

}


### @MappedSuperclass
JPA Entity 클래스들이 해당 추상 클래스를 상속할 경우 createDate, modifiedDate를 컬럼으로 인식

### @EntityListeners(AuditingEntityListener.class)
해당 클래스에 Auditing 기능을 포함

### @CreatedDate/@LastModifiedDate
Entity가 생성되어 저장될 때 시간이 자동 저장
조회한 Entity의 값을 변경할 때 시간이 자동 저장



[참고자료] : JPA Auditing 기능이란? - 준영이의 웹 까페
https://webcoding-start.tistory.com/53






## 연관 관계 매핑
---

### @ManyToOne

: N:1 에서 N에 해당하는 엔티티가 1에 해당하는 엔티티와 연관관계를 매핑할 때 `@ManyToOne` 어노테이션을 씁니다.

`@ManyToOne(fetch = FetchType.LAZY)`
- LAZY(지연): 필요할 때 데이터들을 로딩한다. - 모든 연관관계는 지연관계로 설정할 것.

### @OneToMany

: 1에 해당하는 엔티티가 N에 해당하는 엔티티와 관계가 있음을 명시
    이때, **N에 해당하는 엔티티에서 ManyToOne이 설정 된 멤버변수를 mappedBy** 합니다.

Member.java
`@OneToMany(mappedBy = "member", cascade = CascadeType.ALL)`
- cascade=CascadeType.ALL
    : 엔티티의 영속성 상태가 변화할 때 연관된 엔티티도 함께 변화한다.
    cascade의 타입에는 PERSIST, MERGE, REMOVE, REFRESH, DETACH, ALL 6가지 속성이 있다.

### @JoinColumn
실제 데이터베이스에서 해당 칼럼(외래키)의 이름을 설정하는 것입니다.





## 칼럼 별 세부 설정
---
### @Column(...)

Ex.
`@Column(nullable = false, length = 40)`
`@Column(columnDefinition = "VARCHAR(10)")`
`@Column(columnDefinition = "VARCHAR(15) DEFAULT 'ACTIVE'")`

- mysql은 문자열을 무조건 `''`로 감싸야 한다.
- 칼럼의 디폴트 값은 `@ColumnDefault('ACTIVE')` 같은 형태로도 가능함

[UMC] 4주차. Spring Boot 코어개념

Thu, 24 Oct 2024 05:00:37 GMT

중간시험이 모두 끝나고 4, 5주차를 한꺼번에 공부하게 되었다... 앞의 1,2,3주차에서는 Spring boot를 배우기 전에 백엔드 개발을 위한 필수적인 사전 지식을 공부하였다면, 이번 주차부터는 본격적으로 Spring boot에 대해 배운다.

🌱Spring이란?

엔터프라이즈용 Java 애플리케이션 개발을 편하게 할 수 있게 해주는 오픈소스 경량급 애플리케이션 프레임워크

⭐ 프레임워크(Framework)

프레임워크란, 어떠한 목적을 쉽게 달성할 수 있도록 해당 목적과 관련된 코드의 뼈대를 미리 만들어 둔 것. (프레임 위에서의 작업)

🧑‍💻 프레임워크 vs API vs 라이브러리

API (Application Programming Interface)

API는 2개 이상의 소프트웨어 컴포넌트 사이에서 상호작용 할 수 있도록 정의된 인터페이스를 말합니다. 즉, 다른 개발자들이 사용할 수 있도록 함수나 메서드, 클래스를 정의하는 것입니다.

라이브러리와 API를 혼동하기 쉬운데, 실제 개발을 할 때는 여러 컴포넌트를 합쳐서 개발을 하게 되고, 각각의 컴포넌트들은 API를 가지고 있습니다. 이때 많은 컴포넌트들이 라이브러리의 형태로 제공되기 때문에 API와 라이브러리를 혼동할 수 있습니다. 하지만, 라이브러리는 컴포넌트 자체를 의미하고, API는 그 컴포넌트를 활용하기 위한 규약입니다.

Vs. Framework

프레임워크는 응용프로그램이나 소프트웨어 구현을 수월하게 하기 위해 제공된 소프트웨어 환경이다. 라이브러리는 우리가 선택적으로 끌어다 쓰는 것과 달리 프레임워크는 프레임워크에 의존하여 개발해야하고, 프레임워크가 정의한 규칙을 준수해야한다.

⭐ Spring IoC 컨테이너

Spring IoC (제어의 역전: Inversion of Control) 컨테이너는 객체의 생성과 관리를 개발자가 아닌 Spring 프레임워크가 직접 담당하는 개념입니다. 개발자는 필요한 객체만 선언해 두고, Spring이 알아서 적절한 객체를 주입해주는 형태이죠.
👉🏻 그러므로 '제어의 역전'은 객체의 생성, 생명주기의 관리까지 모든 객체에 대한 제어권이 개발자에서 컨테이너에게로 바뀌었다는 뜻입니다.

컨테이너: 컨테이너는 보통 객체의 생명주기를 관리, 생성된 인스턴스들에게 추가적인 기능을 제공하도록 하는 것이다.

- IoC 컨테이너의 작동 방식

객체를 class로 정의합니다.
객체들 간의 연관성을 지정: Spring설정 파일(Config) 또는 어노테이션(@Component, @Cinfiguration, @Autowired, @Bean)을 통해 객체들이 어떻게 연결될지 (의존성 주입) 지정해줍니다.
IoC 컨테이너가 이 정보를 바탕으로 객체들을 생성하고 필요한 곳에 주입합니다.

👉🏻 POJO (Plain Old Java Object) 기반의 개발을 가능하게 한다! : 복잡한 라이브러리나 프레임워크에 의존/종속적 X, 순수한 자바 객체

⭐ 빈(Bean)

spring 컨테이너가 관리하는 자바의 객체를 의미. ApplicationContext.getBean() 함수를 호출하면 얻어지는 것이 Sping의 빈이다.

Bean을 통해 객체를 인스턴스화 -> 객체 간의 의존 관계 관리
객체 생성할 때,

new 로 객체 직접 생성 -> 객체 생성과 의존성 관리를 개발자가 전적으로 책임져야 함.

그러므로 아래와 같이 빈으로 등록하여 관리하는 방법이 있다.

✨ Bean으로 등록하여 관리하는 방식

1) @Component -> @Autowired : 묵시적 Bean 정의 클래스에 Component 어노테이션 추가하여 Spring이 자동으로 해당 클래스를 스캔하고 Bean으로 등록하도록 한다. 그리고 Autowired로 다른 클래스에서 해당 Bean을 끌어온다.

2) @Configuration -> @Bean : 명시적 Bean 정의 Spring 설정 파일에 Configuration 어노테이션을 추가하고, Bean 어노테이션을 붙여 명시적으로 빈을 지정한다.

🧑‍💻 의존성 주입

⭐ Spring DI (Dependency Injection)

'의존성 주입'은 객체 인스턴스에 설정된 속성을 통해서만 종속성을 정의하는 프로세스

Spring 컨테이너는 빈을 생성할 때, 이러한 종속성을 주입한다.

이 프로세스는 기본적으로 클래스를 직접 생성, service locater 패턴을 사용하여 종속성의 인스턴스화 또는 위치를 스스로 제어하는 것과는 전혀 반대이다. (Inversion of Control)

DI 원칙을 사용하면,

👉🏻 코드가 더 깔끔해지고, 객체에 종속성이 제공되어 분리가 더 효과적이다.

의존성을 왜 외부로부터 주입받아야 할까❓

개발을 하며 만드는 객체들은 서로 의존되어있을 수밖에 없다. 필연적으로 서로 의존성을 지닐 수 밖에 없기 때문에 객체들 간에 결합이 생긴다.

CoffeeBeans를 인터페이스로 구현

public interface CoffeeBeans {
    void grind();
}

인터페이스를 구현하는 구현체 클래스를 만든다.

public static class RegularCoffeeBeans implements CoffeeBeans{
    @Override
    public void grind(){
        System.out.println("기본 원두로 가는 중")
    }
}

다른 원두를 쓰고 싶을 때는 '디카페인'이라는 구현체 클래스를 하나 정의

public static class DecafCoffeeBeans implements CoffeeBeans {
    @Override
    public void grind() {
        System.out.println("디카페인 원두로 가는 중")
    }
}

👉🏻 이처럼 각 객체끼리의 의존성이 존재할 때, 의존성을 외부에서 주입받는 것이 바람직합니다.
그리고, Spring은 이런 의존성 주입을 자동화해줌으로써, 개발자의 부담을 줄여줍니다.

⭐ Spring의 의존성 주입 방식

1️⃣ 생성자 주입 (Constructor Injection) - 스프링 공식 문서 권장 방식 2️⃣ setter 주입 (Setter Injection) - 의존 관계가 선택적이거나 변경 가능한 경우 3️⃣ 필드 주입 (Field Injection)

1️⃣ 생성자(Constructor) 주입 방식

생성자 주입은 생성자를 통해서 의존 관계를 주입받는 방법이다.

생성자에 @Autowired를 하면 스프링 컨테이너에 @Component로 등록된 빈에서 생성자에 필요한 빈들을 주입한다.

👉🏻 객체가 생성될 때 필요한 의존성을 모조리 설정해버린다. 이는 객체의 불변성(immunability)를 보장해준다.

@Service
public class MemberSignupService {
    private final MemberRepository memberRepository;

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

생성자 호출 시점에 1번만 호출되는 것을 보장. 객체 생성될 때 필수적인 의존성(필드값)들을 보장. (의존성 없는 객체 X) 주입받을 필드를 final로 선언 가능하다.

2️⃣ Setter 주입 방식

런타임에 의존성을 주입하기 때문에, 의존성이 없더라도 객체 생성이 가능.

주입 받으려는 빈의 생성자를 호출하여 빈을 찾거나 빈 팩토리에 등록
생성자 인자에 사용하는 빈을 찾거나 생성
Setter의 인자로 주입

선택적으로 의존성 주입이 가능 NullPointException 에러가 발생할 수 있다는 매우 치명적 단점!

3️⃣ 필드(Field) 주입 방식

Setter 주입 방식과 마찬가지로, 런타임에 의존성을 주입하기 때문에 의존성이 없더라도 객체가 생성될 수 있다.

주입받으려는 빈의 생성자를 호출 -> 빈을 찾거나 빈 팩토리에 등록
생성자 인자에 사용하는 빈을 찾거나 생성
필드에 주입

필드에 직접 주입되기 때문에 테스트 중에 의존성을 주입하는 것이 어렵다는 단점이 있다. 의존성이 명시적으로 드러나지 않기 때문에 구조를 이해하기 어렵다. -> Bean들 간의 순환 참조 문제가 발생할 수 있다.

[참고 자료] https://ittrue.tistory.com/227

⭐ Spring 서블릿(Servlet)

웹 어플리케이션에서 클라이언트의 요청을 처리, 그에 대한 응답을 생성

Servlet Container?

Servlet을 관리해주는 컨테이너 역할

DispatcherServlet?

Front Controller 패턴을 구현한 서블릿. 모즌 HTTP 요청을 받는 서블릿이다.

[참고 자료] Spring MVC 동작 구조 : https://iri-kang.tistory.com/4

[Kotlin] List Vs. Mutable List

Wed, 23 Oct 2024 07:57:35 GMT

참고 문헌 https://kt.academy/article/ek-mutable-collections

The biggest advantage of using mutable collections instead of immutable collections is that their performance is faster. When we add an element to an immutable collection, we need to create a new collection and add all elements to it. Here is how this is currently implemented in Kotlin stdlib
When we deal with bigger collections, adding multiple elements to another collection can be a costly process. This is why using mutable collections, especially if we often need to add elements, is a performance optimization.

Adding mutable collections to elements is generally faster, but immutable collections give us more control over how they are changed. However, in the local scope we generally do not need this control, so mutable collections should be preferred, especially in util functions, where element insertion might happen many times.

[UMC] 1주차. DB설계

Sun, 22 Sep 2024 05:31:48 GMT

데이터베이스 설계의 방법?

상황에 따른 설계
직접 설계해보자!

들어가기 전에

사전지식

데이터의 CRUD (Create, Read, Update, Delete) : 데이터를 다루는 가장 기본적인 동작

-> MySQL 기초 문법 DESC : describe 테이블 구조 확인 SHOW : 테이블 조회

// Create
CREATE TABLE 테이블명 (
    MYKEY INT,    // 컬럼명 데이터형,
    PRODUCT_ID TEXT,
    TITLE TEXT
    ...
    PRIMARY KEY(MYKEY)    // (기본키가 될 필드명)
);
INSERT INTO ... VALUES ...;

// Read
SELECT ... FROM ...;

// Update
UPDATE ... SET ... WHERE ...;

// Delete
DROP TABLE 테이블명;    // 테이블 삭제
DELETE FROM ... WHERE ...;

⭐ ERD는 프로젝트 시작과 동시에 설계하는 것이 좋습니다.

ERD(Entity Relationship Diagram) 설계

: 데이터 구조를 한눈에 알아보기 위해서 쓰인다. 테이블들의 구조화된 다이어그램

Entity (개체)
Attribute (속성)
Relationship (관계) 관계 형태

SQL과 NoSQL

SQL

: 데이터베이스를 사용하는 시스템에서 데이터를 관리하는 데 사용되는 언어 관계가 잘 정의된 구조화된 데이터에 좋습니다.

NoSQL

: Not Only SQL의 약자로 SQL을 사용하지 않는 DBMS들을 의미합니다. 다양한 데이터 구조를 지원한다. 데이터 요소 간의 관계가 잘 정의되어 있지 않은 반정형, 비정형 데이터에 적합하다.

유저 테이블을 어떻게 설계하는 것이 좋을까?

N:M(다대다) 관계는 어떻게 하는 것이 좋을까?
알림을 보내야 하는 경우는 어떻게 하는 것이 좋을까?

데이터베이스 설계

[SpringBoot3] JWT 토큰 서비스

Wed, 04 Sep 2024 07:56:36 GMT

👉🏻 이 글은 <스프링부트3 백엔드 개발자 되기-자바편(2판)>의 9장을 공부하며 작성한 글입니다.

JWT (Json Web Token) : 웹 표준을 따르며 JSON 객체를 사용하여 정보를 전달한다. 토큰 기반의 인증 방법을 사용한다.

📌 토큰 기반 인증

사용자가 서버에 접근할 때 사용자가 인증된 사용자인지 확인하는 방법 두 가지

1. 서버 기반 인증

세션 기반 인증 : 스프링 시큐리티 기본적으로 제공해주는 세션 기반 인증을 사용해 사용자마다 사용자의 정보를 담은 세션을 생성하고 서버의 세션 저장소에 저장해서 인증을 함.
세션 개념 참고 : (https://hudi.blog/cookie-and-session/)

2. 토큰 기반 인증

토큰: 서버에서 클라이언트를 구분하기 위한 유일한 값 서버가 토큰을 생성래서 클라이언트에게 제공 -> 클라이언트는 이 토큰을 가지고 있다가 여러 토큰과 함께 신청 -> 서버가 유효한 사용자인지 검증

📖 토큰을 전달하고 인증받는 과정

책의 내용을 위와 같이 그림으로 정리함.

📖 토큰 기반 인증의 특징

무상태성
무상태성은 사용자의 인증 정보가 담겨 있는 토큰이 서버가 아닌 클라이언트에 있으므로 서버에 저장할 필요가 없는 것이다. 즉, 클라이언트가 토큰을 생성하고 인증, 인증 상태를 유지하면서 요청 처리(=상태 관리) 하므로 서버 입장에서는 클라이언트의 인증정보를 저장하거나 유지하지 않아도 되기 때문에 완전한 무상태로 효율적인 검증이 가능하다.
확장성
서버를 확장할 때 상태 관리를 신경 쓸 필요가 없으니(무상태성) 서버 확장에도 용이한 것이다. 세션 기반 인증은 각각 API에서 인증을 해야되는 것과는 달리 토큰 기반 인증에서는 토큰을 가지는 주체는 서버가 아닌 클라이언트이기 때문에 가지고 있는 하나의 토큰으로 결제 서버와 주문 서버에 요청을 보낼 수 있다. 추가로 다른 토큰 기반 인증을 사용하는 다른 시스템에 접근해 로그인 방식을 확장할 수도 있고, 다른 서비스에 권한을 공유할 수도 있다.
무결성
토큰 방식은 HMAC(hash-based message authenticarion)이라고도 부르는데, 토큰을 발급한 이후에는 토큰 정보를 변경하는 행위를 할 수 없다. 즉, 토큰의 무결성이 보장되는 것이다. 만약 누군가 토큰을 변경한다면 서버에서는 유효하지 않은 토큰으로 판단한다.

📌 JWT

발급받은 JWT를 이용해 인증을 하려면 HTTP 요청 헤더 중, Authorization 키값에 Bearer + JWT 토큰값 을 넣어 보내야 합니다.

📖 JWT의 구조

JWT는 .을 기준으로 헤더(header) / 내용(payload) / 서명(signature) 으로 이루어져 있습니다.

- 토큰 생성 메서드 예시

TokenProvider.java - makeToken 메서드

// JWT 토큰 생성 메서드
private String makeToken(Date expiry, User user){
    Date now = new Date();

    // JWT = 헤더.내용.서명
    return Jwts.builder()
            // 헤더 typ : JWT
            .setHeaderParam(Header.TYPE, Header.JWT_TYPE) 
            // 내용 iss : ajufresh@gmail.com(propertise 파일에서 설정한 값)
            .setIssuer(jwtProperties.getIssuer())
            .setIssuedAt(now)   // 내용 iat : 현재 시간
            .setExpiration(expiry)  // 내용 exp : expiry 멤버 변숫값
            .setSubject(user.getEmail())    // 내용 sub : 유저의 이메일
            .claim("id", user.getId())  // 클레임 id : 유저 ID
            // 서명 : 비밀값과 함께 해시값을 HS256 방식으로 암호화
            .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecretKey())
            .compact();
}

📖 토큰 유효기간

❓ 만약 토큰 자체가 노출된다면? 토큰은 이미 발급되면 그 자체로 인증 수단이 되므로 서버는 토큰과 함께 들어온 요청이 토큰을 탈취한 사람의 요청인지 확인할 수 없다.

❗리프레시 토큰 보안을 위해서는 토큰의 유효기간이 짧으면 되겠지만, 토큰의 유효기간이 너무 짧으면 사용자 입장에서는 불편할 수 있다.

➡️ 액세스 토큰의 유효기간을 짧게 하고, 리프레시 토큰의 유효기간을 길게 설정!

리프레시 토큰은 액세스 토큰과 별개로 액세스 토큰이 만료되었을 때 새로운 액세스 토큰을 발급하기 위해 사용한다.

📖 액세스 토큰과 리프레시 토큰 전달 & 인증 과정

이를 이해하고 JWT 서비스를 구현하면 됨.

[spring-boot3] 스프링 시큐리티

Thu, 29 Aug 2024 13:25:26 GMT

스프링 부트3 백엔드 개발자 되기 (자바편) 07장 : 스프링 부트3 구조 이해하기를 공부하고 작성한 내용입니다.

스프링 시큐리티

: 스프링 기반의 애플리케이션 보안(인증, 인가, 권한)을 담당하는 스프링 하위 프레임워크이다. 보안 관련 옵션을 제공한다.

인증: authentication 사용자의 신원을 입증하는 과정. 예를 들어 사이트에 로그인할 때 누구인지 확인하는 과정
인가: authorization 사이트의 특정 부분에 접근할 수 있는지에 권한을 확인하는 작업. (일반 사용자가 관리자 페이지에 들어갈 수 없는 것)

스프링 시큐리티는 필터 기반으로 동작한다. 필터 구조를 살펴보자.

SecurityFilterChain 위에서 아래로 순서대로 필터를 거친다. 필터를 실행할 때는 화살표로 연결된 오른쪽의 클래스들을 거치며 실행한다.

⭐ UsernamePasswordAuthenticationFilter : 아이디와 패스워드가 넘어오면 인증 요청을 위임하는 인증 관리자 역할

⭐ FilterSecurityInterceptor : 권한 부여 처리를 위임해 접근 제어 결정을 쉽게 하는 접근 결정 관리자 역할

[spring-boot3] ORM

Fri, 09 Aug 2024 07:56:59 GMT

스프링 부트3 백엔드 개발자 되기 (자바편) 05장 : 데이터베이스 조작이 편해지는 ORM을 공부하고 작성한 내용입니다. 출처: https://wikidocs.net/237210

DBMS

: DataBase Management System 효율적으로 데이터베이스를 관리하고 운영하는 소프트웨어 ( MySQL, Oracle )

관계형 DBMS (RDBMS) : MySQL, H2 (스프링부트가 지원하는 인메모리 관계형 데이터베이스)

ORM

: Object-relation Mapping

자바의 객체와 데이터베이스를 연결하는 프로그래밍 기법
자바 코드를 통해 데이터베이스의 값을 객체처럼 사용
복잡하고 무거운 쿼리는 ORM로 해결이 불가능한 경우가 있습니다.

JPA

: Java Persistence API

자바 객체와 데이터베이스를 연결해 데이터를 관리한다.
객체지향 도메인 모델과 데이터베이스의 다리 역할을 한다.
ORM의 한 종류로 자바에서 관계형 데이터베이스를 사용하는 방식을 정의한 인터페이스이다.
인터페이스이므로 실제 사용을 위해서는 ORM 프레임워크를 추가로 선택해야한다. -> 대표적으로 하이버네이트를 사용한다.

하이버네이트

: hibernate

JPA를 구현한 구현체(JPA의 인터페이스를 구현)이자 자바용 ORM 프레임워크
내부적으로 JDBC API를 사용한다.
자바 객체를 통해 데이터베이스 종류에 상관없이 데이터베이스를 자유자재로 사용할 수 있게 한다.

엔티티

: Entity

데이터베이스의 테이블과 매핑되는 객체를 의미. 본질적으로 자바 객체이므로 일반 객체와 다르지 않다.
하지만 데이터베이스의 테이블과 직접 연결된다는 아주 특별한 특징이 있어 구분지어 부릅니다.

엔티티 매니저

: Entity manager

엔티티를 관리해 데이터베이스와 어플리케이션 사이에서 객체를 생성, 수정, 삭제하는 등의 역할을 합니다.
이런 엔티티 매니저를 만드는 곳이 엔티티 매니저 팩토리입니다.

✅ 스프링부트에서는 직접 엔티티 매네저 팩토리를 만들어서 관리하지 않고 내부에서 엔티티 매니저 팩토리를 하나만 생성해서 관리하고 @PersistenceContext 또는 @Autowired 애너테이션을 사용해서 엔티티 매니저를 관리한다.

기본적으로 빈을 하나만 생성해서 공유하므로 동시성 문제가 발생할 수 있어 실제 엔티티 매니저와 연결하는 프록시(가짜) 엔티티 매니저를 이용한다.
엔티티 매니저는 Spring Data JPA에서 관리하므로 직접 생성하거나 관리할 필요가 없다.

영속성 컨텍스트

: 엔티티를 관리하는 가상의 공간. 엔티티 매니저는 엔티티를 영속성 컨텍스트에 저장한다.

- 1차 캐시

영속성 컨텍스트는 내부에 1차 캐시를 가지고 있습니다. 이때 캐시의 키는 엔티티의 @Id 애너테이션이 달린 기본키 역할을 하는 식별자이며 값은 엔티티입니다. 엔티티를 조회하면 1차 캐시에서 데이터를 조회하고 값이 있으면 반환합니다. 값이 없으면 데이터베이스에서 조회해 1차 캐시에 저장한 다음 반환합니다. 이를 통해 캐시된 데이터를 조회할 때에는 데이터베이스를 거치치 않아도 되므로 매우 빠르게 데이터를 조회할 수 있습니다

- 쓰기 지연

쓰기 지연transactional write-behind은 트랜잭션을 커밋하기 전까지는 데이터베이스에 실제로 질의문을 보내지 않고 쿼리를 모았다가 트랜잭션을 커밋하면 모았던 쿼리를 한번에 실행하는 것을 의미합니다. 예를 들어 데이터 추가 쿼리가 3개라면 영속성 컨텍스트는 트랜잭션을 커밋하는 시점에 3개의 쿼리를 한꺼번에 쿼리를 전송합니다. 이를 통해 적당한 묶음으로 쿼리를 요청할 수 있어 데이터베이스 시스템의 부담을 줄일 수 있습니다.

- 변경 감지

트랜잭션을 커밋하면 1차 캐시에 저장되어 있는 엔티티의 값과 현재 엔티티의 값을 비교해서 변경된 값이 있다면 변경 사항을 감지해 변경된 값을 데이터베이스에 자동으로 반영합니다. 이를 통해 쓰기 지연과 마찬가지로 적당한 묶음으로 쿼리를 요청할 수 있고, 데이터베이스 시스템의 부담을 줄일 수 있습니다.

- 지연 로딩

지연 로딩lazy loading은 쿼리로 요청한 데이터를 애플리케이션에 바로 로딩하는 것이 아니라 필요할 때 쿼리를 날려 데이터를 조회하는 것을 의미합니다.

⬇️ 이 특징들이 갖는 공통점은 모두 데이터베이스의 접근을 최소화해 성능을 높일 수 있다는 것입니다. 캐시를 하거나, 자주 쓰지 않게 하거나, 변화를 자동 감지해서 미리 준비하거나 한다.

엔티티의 상태

분리 상태 : 영속성 컨테스트가 관리하고 있지 않은 상태 관리 상태 : 영속성 컨테스트가 관리하고 있는 상태 비영속 상태 : 영속성 컨테스트와 전혀 관계가 없는 상태 삭제된 상태 : 삭제된 상태

특정 메서드 호출로 상태 변경 가능.

✅ ORM부터 JPA, 하이버네이트, 스프링 데이터 JPA를 알아보았습니다. ORM은 관계형 데이터베이스와 프로그램 간의 통신 개념, JPA는 자바 애플리케이션에서 관계형 데이터베이스를 사용하는 방식을 정의한 기술 명세, 하이버네이트는 JPA의 구현체, 스프링 데이터 JPA는 JPA를 쓰기 편하게 만들어 놓은 모듈입니다.

ORM은 객체와 데이터베이스를 연결하는 프로그래밍 기법입니다.
JPA는 자바에서 관계형 데이터베이스를 사용하는 방식을 정의한 인터페이스입니다.

엔티티는 영속성을 가진 객체를 의미합니다.
엔티티 매니저는 엔티티를 관리하며 조회, 삭제, 수정, 생성하는 역할을 합니다.
엔티티 매니저를 만드는 곳이 엔티티 매니저 팩토리입니다.
엔티티 매니저는 엔티티를 영속성 컨텍스트에 저장한다는 특징이 있습니다.
엔티티의 상태는 분리, 관리, 비영속, 삭제 상태로 나뉩니다.

하이버네이트는 JPA의 대표적인 구현체로, 자바 언어를 위한 ORM 프레임워크입니다.
스프링 데이터 JPA는 JPA를 쓰기 편하게 만들어놓은 모듈입니다.

출처: https://wikidocs.net/237210

[spring-boot3] 테스트 코드

Thu, 08 Aug 2024 17:18:28 GMT

스프링 부트3 백엔드 개발자 되기 (자바편) 04장 : 스프링 부트 3와 테스트를 공부하고 작성한 내용입니다. 출처: https://wikidocs.net/237060

⭐ 테스트 코드

: 작성한 코드가 의도대로 잘 동작하고 예상치 못한 문제가 없는지 확인할 목적으로 작성하는 코드

테스트 코드는 test 디렉터리에서 작업
다양한 패턴이 존재
- given-when-then 패턴
  1. given : 테스트 실행을 준비
  2. when : 테스트 진행
  3. then : 테스트 결과를 검증
스프링 부트는 spring-boot-starter-test스타터에서 애플리케이션을 테스트하기 위한 도구와 애너테이션을 제공한다. (JUnit, Spring Test & Spring Boot Test, AssertJ, Mockito...)

✅ JUnit (단위 테스트 코드 만들기)

JUnit : 자바 프로그래밍 언어용 단위 테스트 프레임워크
- 테스트 방식을 구분할 수 있는 애너테이션을 제공
- @Test 애너테이션으로 메서드를 호출할 때마다 새 인스턴스를 생성, 독립 테스트 가능
- 예상 결과를 검증하는 어설션 메서드 제공
- 사용 방법이 단순, 테스트 코드 작성 시간이 적음
- 자동 실행, 자체 결과를 확인하고 즉각적인 피드백을 제공

✅ AssertJ (검증문 가독성 높이기)

AssertJ는 JUnit과 함께 사용해 검증문의 가독성을 확 높여주는 라이브러리입니다. 이를테면 앞서 작성한 테스트 코드의 Assertion은 기댓값과 실제 비교값을 명시하지 않으므로 비교 대상이 헷갈립니다.

▼ 기댓값과 비교값이 잘 구분되지 않는 Assertion 예

Assertions.assertEquals(sum, a + b);

▼ 가독성이 좋은 AssertJ 예

assertThat(a + b).isEqualTo(sum);

AssertJ에서 다양한 메서드 제공

[spring-boot3] 요청-응답 과정

Thu, 08 Aug 2024 16:44:27 GMT

스프링 부트3 백엔드 개발자 되기 (자바편) 03장 : 스프링 부트3 구조 이해하기를 공부하고 작성한 내용입니다. 출처: https://wikidocs.net/237058

3.3 스프링 부트 요청-응답 과정 한 방에 이해하기

① 그림을 보면 포스트맨에서 "톰캣"에 /test GET 요청을 합니다. 그러면 이 요청은 스프링 부트 내로 이동하는데요. 이때 스프링 부트의 디스패처 서블릿이라는 녀석이 URL을 분석하고, 이 요청을 처리할 수 있는 컨트롤러를 찾습니다. TestController가 /test라는 패스에 대한 GET 요청을 처리할 수 있는 getAllMembers( ) 메서드를 가지고 있으므로 디스패처 서블릿은 TestController에게 /test GET 요청을 전달합니다.

② 마침내 /test GET 요청을 처리할 수 있는 getAllMembers( ) 메서드와 이 요청이 매치됩니다. 그리고 getAllMembers( ) 메서드에서는 비즈니스 계층과 퍼시스턴스 계층을 통하면서 필요한 데이터를 가져옵니다.

③ 그러면 뷰 리졸버는 템플릿 엔진을 사용해 HTML 문서를 만들거나 JSON, XML 등의 데이터를 생성합니다.

④ 그 결과 톰캣이 members를 return하고 그 데이터를 포스트맨에서 볼 수 있게 됩니다.

[Java] Ch.16 네트워킹(Networking)

Sun, 21 Jul 2024 11:09:08 GMT

👉🏻 이 글은 자바의 정석(3판) Ch.16을 공부하며 적은 내용입니다.

URL

프로토콜://호스트명:포트번호/경로명/파일명?쿼리스트링#참조

포트번호, 쿼리, 참조는 생략 가능

프로토콜: 자원에 접근하기 위해 서버와 통신하는데 사용되는 통신 규약(http) 호스트명: 자원을 제공하는 서버의 이름 포트번호: 통신에 사용되는 서버의 포트번호 경로명: 접슨하려는 자원이 저장된 서버상의 위치 파일명: 접근하려는 자원의 이름 쿼리(query) 참조(anchor)

URL 객체 생성 URL url = new URL("http://.......html");

URLConnection

어플리케이션과 URL간의 통신연결을 나타내는 클래스의 최상위 클래스로 추상클래스이다. (HttpURLConnection, JarURLConnection이 URLConnection을 상속받아 구현하였다.) URLConnection을 이용해서 연결하고자 하는 자원에 접근하고 읽고 쓰기를 할 수 있다.

public static void main(String args[]){
        URL url = null;
        BufferedReader input = null;
        String address = "http://www.codechobo.com/sample/hello.html";
        String line = "";

        try{
            url = new URL(address);
            input = new BufferedReader(new InputStreamReader(url.openStream()));

            while((line = input.readLine()) != null){
                System.out.println(line);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

openStream()은 openConnection()을 호출해서 URLConnection을 얻은 다름 여기에 다시 getInputStream()을 호출한 것과 같다.즉, URL에 연결해서 InputStream을 얻어온다.

📌 소켓 프로그래밍

소켓 프로그래밍 : 소켓을 이용한 통신 프로그래밍을 뜻한다. 소켓(socket) : 프로세스간의 통신에 사용되는 양쪽 끝단(endpoint).

java.net패키지를 통해 소켓프로그래밍 지원. 소켓통신에 사용되는 프로토콜에 따라 다른 종류의 소켓을 구현하여 제공.

TCP / UDP

TCP/IP 프로토콜은 이기종 시스템간의 통신을 위한 표준 프로토콜로 프로토콜의 집합이다.

TCP와 UDP는 전송방식이 다르다.

항목	TCP	UDP
연결방식	연결 기반 - 연결 후 통신(전화기) - 1:1 통신 방식	비연결 기반 - 연결없이 통신(소포) - 1:1, 1:n, n:n 통신 방식
특징	데이터의 경계를 구분하지 않음 신뢰성 있는 데이터 전송 - 전송 순서 보장 - 수신 여부 확인함 - 패킷 관리 필요 없음 UDP보다 전송속도가 느림.	데이터의 경계를 구분함.(datagram) 신뢰성 없는 데이터 전송 - 전송 순서 바뀔 수 있음 - 수신여부 확인 안함 - 패킷 관리해주어야 함. TCP보다 전송속도 빠름.
관련 클래스	Socket ServerSocket	DatagramSocket DatagramPacket MulticastSocket

TCP소켓 프로그래밍

서버 프로그램에서는 서버소켓을 사용해서 서버 컴퓨터의 특정 포트에서 클라이언트의 연결요청 처리 준비한다.
클라이언트 프로그램은 접속할 서버의 IP주소와 포트 정보를 가지고 소켓을 생성해서 클라이언트의 소켓과 연결되도록 한다.
서버소켓은 클라이언트의 연결요청을 받으면 서버에 새로운 소켓을 생성햐서 클라이언트의 소켓과 연결되도록 한다.
이제 클라이언트의 소켓과 새로 생성된 서버의 소켓은 서버소켓과 관계없이 일대일 통신을 한다.

UCP소켓 프로그래밍

연결지향적인 프로토콜이 아니기 때문에 ServerSocket이 필요하지 않다. UCP통신에서 사용하는 소켓은 DatagramSocket이며, 데이터를 DatagramPacket에 담아서 전송한다. DatagramPacket은 헤더와 데이터로 구성되어 있으며, 헤더에는 수신할 호스트의 정보가 저장되어 있다.

[Java] Ch.13 쓰레드

Fri, 19 Jul 2024 06:51:34 GMT

👉🏻 이 글은 자바의 정석(3판) Ch.13을 공부하며 적은 내용입니다.

📌 프로세스와 쓰레드

- 프로세스(process)

: '실행 중인 프로그램'

프로그램을 실행하면 OS로부터 실행에 필요한 자원(메모리)를 할당받아 프로세스가 된다.
프로세스는 프로그램을 실행하는 데 필요한 데이터와 메모리 등의 자원 그리고 쓰레드로 구성되어 있다.

- 쓰레드(thread)

: 프로세스의 자원을 이용해서 실제로 작업을 수행하는 것.

모든 프로세스에는 하나 이상의 쓰레드가 존재하며, 둘 이상의 쓰레드를 '멀티쓰레드 프로세스' 라고 부른다.

- 멀티 테스킹 / 멀티 쓰레딩

멀티 테스킹 (다중 작업) : 대부분의 OS는 멀티테스킹을 지원하기 때문에 여러 개의 프로세스가 동시에 실행될 수 있다.
⭐ 멀티 쓰레딩 : 하나의 프로세스 내에서 둘 이상의 쓰레드가 동시에 작업을 수행하는 것이다. CPU의 사용률을 향상시킨다, 각 쓰레드가 프로세스의 메모리를 공유하므로 시스템 자원의 낭비가 적다, 사용자와의 응답성이 좋아진다. 멀티 스레드 프로그램은 공유하는 자원에 대해 동기화 문제가 발생할 수 있다. CPU의 core는 한 번에 단 하나의 작업만 수행할 수 있으므로 실제로 동시에 처리되는 작업의 개수는 코어의 개수와 일치한다.

-> 여러 쓰레드가 같은 프로세스 내에서 자원을 공유하며 작업을 하기 때문에 동기화, 교착상태 같은 문제들 발생 가능

📌 쓰레드의 구현과 실행

Tread 클래스를 상속받는 방법과 Runnable인터페이스를 구현하는 방법 두 가지가 있다. 차이는 별로 없지만 Thread클래스를 상속받으면 다른 클래스를 상속받을 수 없기 때문에 일반적으로 Runnable인터페이스를 구현한다.

Thread를 상속받을 경우와 Runnable인터페이스를 구현할 때의 인스턴스 생성방법이 다르다.

1. Thread클래스 상속받기

class MyThread extends Thread {
    public void run() { /*작업내용*/ }    // Thread클래스의 run()을 오버라이딩
}

- 인스턴스 생성

MyThread t = new MyThread();    // Thread 자손 클래스의 인스턴스 생성

2. Runnable인터페이스 구현하기

class MyThread implements Runnable {
    public void run() { /*작업내용*/ }    // Runnable인터페이스의 run()을 구현
}

Runnable인터페이스는 오직 run()만 정의되어 있는 간단한 인터페이스이다.

// Runnable인터페이스 내용
public interface Runnable{
    public abstract void run();
}

"쓰레드를 구현한다" = 쓰레드를 통해 작업하고자 하는 내용으로 run()의 몸통 { }을 채운다는 것이다.

- 인스턴스 생성

class Thread_2 implements Runnable {
    public void run() {
        ...
    }
}

Runnable r = new Thread_2();
Thread t2 = new Thread(r);        //생성자 Thread(Runnable target)

// ⬇️ 위의 두 줄을 간단히
Thread t2 = new Thread(new Thread_2());

Runnable인터페이스를 구현한 Thread_2에는 멤버가 run()밖에 없기 때문에 쓰레드의 이름을 호출할 때 Thread.currentTread().getName();와 같이 해야한다.

👉🏻 쓰레드의 실행

start()를 호출해야만 쓰레드 실행됨.
한 번 실행이 종료된 쓰레드는 다시 시작할 수 없다.
다시 수행하려면 새로운 쓰래드를 new로 다시 생성한다.

run()은 쓰레드를 실행시키는 것이 아님. 단순히 클래스에 선언된 매서드를 호출하는 것임. ➡️ 반면 start()는 쓰레드가 작업 실행에 필요한 호출스택(call stack)을 생성한 다음에 run()을 호출해서 생성된 스택에 run()이 첫번째로 올라가게 한다. (독립된 공간에서 작업을 수행)
실행 중인 사용자 쓰레드가 하나도 없을 때 프로그램은 종료된다.

📌 싱글쓰레드 & 멀티쓰레드

두 쓰레드가 서로 다른 자원을 사용하는 작업의 경우에는 싱글쓰레드 프로세스보다 멀티쓰레드 프로세스가 더 효율적이다. Ex. 사용자로부터 데이터 입력받기, 네트워크로 파일 주고받기....

import javax.swing.JOptionPane;

public class TreadEx {
    public static void main(String[] args) throws Exception{
        ThreadEx th = new ThreadEx();
        th.start();

        String input = JOptionPane.showInputDialog("아무 값이나 입력하세요.");
        System.out.println("입력하신 값은 "+input+"입니다.");
    }

    class ThreadEx extends Thread{
        public void run() {
            for(int i=10; i>0; i--) {
                System.out.println(i);
                try {
                    sleep(10000);
                } catch(Exception e) {}
            }
        }
    }
}

이렇게 하면 사용자가 입력을 마치지 않았어도 숫자가 출력되는 것을 볼 수 있다.

📌 쓰레드의 우선순위

쓰레드의 우선순위는 실행하기 전에만 변경할 수 있다.
void setPriority(int newPriority) : 우선순위 변경
int getPriority() : 우선순위 반환
MAX_PRIORITY = 10 : 최대 우선순위
MIN_PRIORITY = 1 : 최소 우선순위
NORM_PRIORITY = 10 : 중간 우선순위

📌 쓰레드 그룹

모든 쓰레드는 반드시 쓰레드 그룹에 포함되어 있어야 한다. -> 만약 쓰레드 그룹 생성자를 사용하지 않으면 자기 자신의 쓰레드 그룹에 포함되어 있는 것으로 된다.

쓰레드 그룹은 서로 관련된 쓰레드를 그룹으로 다루기 위한 것으로, 묶어서 관리할 수 있게 한다. 자신이 속한 쓰레드 그룹이나 하위 쓰레드 그룹은 변경할 수 있지만, 다른 쓰레드 그룹의 쓰레드를 변경할 수 없다.

ThreadGroup(String name) : 지정된 이름의 새로운 쓰레드 그룹을 생성

쓰레드를 쓰레드 그룹에 포함시키려면 Thread의 생성자를 이용해야한다. Thread(ThreadGroup group, String name) Thread(ThreadGroup group, Runnable target) Thread(ThreadGroup group, Runnable target, String name) Thread(ThreadGroup group, Runnable target, String name, long stackSize)

📌 데몬 쓰레드

일반 쓰레드를 보조하는 역할로, 일반 쓰레드가 모두 종료되면 자동으로 종료된다. Ex. 가비지 컬렉터, 워드 자동저장

📌 쓰레드 실행제어

쓰레드 프로그래밍이 어려운 이유는 스케줄링(scheduling)과 동기화(synchronization)때문이다.

쓰레드의 메서드

: sleep(ling millis), join() - 다른 쓰레드의 작업을 기다린다, interrupt() - 깨워서 실행대기상태, [ stop() - 즉시종료, suspend() - 일시정지, resume() - 실행대기상태로 ], yield() - 실행시간을 다른 쓰레드에게 양보하고 자신은 실행대기상태

[ ]는 쓰레드를 교착상태로 만들기 쉽기 때문에 deprecated되었다.

쓰레드의 상태

NEW : 쓰레드가 생성되고 start()가 호출되지 않은 상태 RUNNABLE : 실행중, 실행가능 상태 BLOCKED : 동기화 블럭에 의해 일시정지된 상태 WAITING, TIMED_WAITTING : 작업이 종료되지는 않았지만 실행가능하지 않은 일시정지 상태 (후자는 정지시간이 지정된 경우) TERMINATED : 쓰레드의 작업이 종료된 상태

sleep() : 일정시간동안 쓰레드를 멈추게한다.

항상 try-catch문으로 예외를 처리해줘야 한다. 매번 처리해주기 번거롭기 때문에 매서드로 만들어서 사용하기도 한다.

void delay(ilong millis) {
    try{
        Tread.sleep(millis);
    } catch(InterruptedException e) {}
}

실제로 영향 받는 것은 main메서드를 실행하는 main쓰레드이다.

join() : 다른 쓰레드의 작업을 기다린다.

th1.join();, th1.join(long millis); : 현재 실행중인 쓰레드가 쓰레드 th1의 작업이 끝날 때까지 기다린다.

sleep()처럼 interrupt()에 의해 대기상태에서 벗어날 수 있으며, 호출부분을 try-catch로 감싸야한다.

📌 쓰레드의 동기화

멀티쓰레드 프로세스의 경우 여러 쓰레드가 같은 프로세스 내의 자원을 공유해서 작업하기 때문에 서로의 작업에 영향을 주게 된다.

그래서 한 쓰레드가 특정 작업을 끝마치기 전까지 다른 쓰레드에 의해 방해받지 않도록 하는 것이 필요하다. 그래서 도입된 개념이 "임계 영역(critical section)"과 "잠금(lock)"이다.

공유 데이터를 사용하는 코드 영역을 임계영역으로 지정해놓고, 공유 데이터가 가지고 있는 lock을 획득한 단 하나의 쓰레드만 이 영역 내의 코드를 수행할 수 있게 한다.

이처럼 한 쓰레드가 진행 중인 작업을 다른 쓰레드가 간섭하지 못하도록 막는 것을 '쓰레드의 동기화(synchronization)'라고 한다.

1. synchronized를 이용한 동기화

synchronized : 임계영역 설정
가장 간단한 동기화 방법이다. 메서드 전체를 임계영역으로 지정하거나 특정한 영역을 임계영역으로 지정할 수 있다.

    public void withdraw(int money){
        if(balance >= money){
            try{ Thread.sleep(1000); } catch(Exception e){}
            balance -= money;
        }
    }

잔고를 확인하는 if문과 출금하는 문장은 하나의 임계영역으로 묶어져야 한다. ⬇️

메소드에 synchronized 붙이기 : 한 쓰레드에 의해 먼저 withdraw가 호출되면, 이 메서드가 종료되어 lock이 반납될 때까지 다른 쓰레드는 withdraw를 호출하더라도 대기상태에 머물게 된다.
```
 public synchronized void withdraw(int money){
     if(balance >= money){
         try{ Thread.sleep(1000); } catch(Exception e){}
         balance -= money;
     }
 }
```

synchronized 블럭 사용

 public void withdraw(int money){
     synchronized(this){
         if(balance >= money){
             try{ Thread.sleep(1000); } catch(Exception e){}
             balance -= money;
         }
     }
 }

wait()과 notify()

wait()에 의해 lock을 반납했다가, 나중에 다시 작업을 진행할 수 있는 상황이 되면 notify()를 호출해서 다시 lock을 얻어서 임계영역에 들어와 중단했던 쓰레드를 다시 진행한다. 이것을 재진입(reentrance)이라고 한다.

매개변수가 있는 wait()은 지정된 시간동안만 기다린다.

2. Lock과 Condition을 이용한 동기화

'java.util.concurrent.locks'패키지가 제공하는 lock클래스들을 이용하는 방법이다. 가은 메서드 내에서만 lock을 걸 수 있다는 제약이 불편할 때 이 lock클래스를 이용한다.

lock 클래스의 종류 3가지

ReentrantLock : 재진입 가능 lock. 가장 일반적인 배타 lock
ReentranrReadWriteLock : 읽기에는 공유적, 쓰기에는 배타적
StampedLock : ReentrantReadWriteLock에 낙관적인 기능 추가

-> 무조건 읽기 lock을 걸지 않고, 쓰기와 읽기가 충돌할 때만 쓰기가 끝난 후에 읽기 lock을 거는 것이다.

[Java] Ch.12 제네릭스, 열거형, 애너테이션

Sun, 14 Jul 2024 14:38:32 GMT

👉🏻 이 글은 자바의 정석(3판) Chapter.12을 공부하고 적은 내용입니다.

📌 1. 제네릭스(Generics)

👉🏻 제네릭스(Generics)란? 다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에 컴파일 시의 타입 체크를 해주는 기능이다. 컴파일 시에 타입을 체크하기 때문에

객체의 타입 안정성을 높이고
형변환의 번거로움이 줄어든다. (코드가 간결해 진다.)

👉🏻 다룰 객체의 타입을 미리 멸시해 줌으로써 번거로운 형변환을 줄여준다.

제네릭 타입은 클래스와 메서드에 선언할 수 있다.

class Box {    // 제네릭 타입 T 선언
    T item;
    void setItem(T item) { this.item = item; }
    T getItem() { return item; }
}

Box b = new Box();    // 제네릭 타입 호출
b.setItem("ABC");

위에서 T는 타입 변수 (타입변수는 T가 아닌 다른 것도 사용 가능) Ex. ArrayList, Map

이들은 기호만 다를 뿐 '임의의 참조형 타입'을 의미한다는 것은 모두 같다.

Box : 제네릭 클래스
T : 타입 변수, 타입 매개변수 (T는 타입 문자)
Box : 원시 타입 (raw type)
String : 대입된 타입 (매개변수화된 타입)
### ⚠️ 제네릭스의 제한

static멤버에 타입변수 T를 사용할 수 없다. : static 멤버는 대입된 타입의 종류에 관계없이 동일한 것이어야 하기 때문.
```
 static T item;    // Error!
 static int compare(T t1, T t2) { ... }    // Error!
```

제네릭 타입의 배열 생성 불가능 : new연산자 때문. 컴파일 시점에 T가 어떤 타입이 될지 전혀 알 수 없기 때문이다. instanceof도 마찬가지이다.

 T[] itemArr;    // OK. T타입의 배열을 위한 참조변수
 T[] toArray(){
     T[] tmpArr = new T[itemArr.length];    // Error! 생성불가
     ...
     return tmpArr;
 }

--> newInstance()와 같이 동적 객체 생성 메서드 이용, Object배열을 생성해서 복사한 다음 T[]로 형변환 하는 방법 사용

- 제네릭 클래스의 객체 생성과 사용

class Box {
  ArrayList list = new ArrayList();

  void add(T item)            { list.add(item);        }
  T get(int i)                { return list.get(i);    }
  ArrayList getList        { return list;            }
  int size()                { return list.size();    }
  public String toString()    { return list.toString(); }

참조변수와 생성자에 대입된 타입이 일치해야 한다. (상속관계도 X)
단, 제네릭 클래스의 타입이 상속관계에 있는 것은 괜찮다.
JDK1.7부터는 추정이 가능한 경우 생성자에 타입 생략 가능.
대입된 타입과 다른 타입의 객체는 추가 불가능 (자손들은 가능)

- 제한된 제네릭스

👉🏻 자손타입으로 제한 가능

class Fruit {
    ArrayList list = new ArrayList;
    ...
}

⚠️ 인터페이스를 구현할 때 또한 implements가 아닌 extends를 사용한다. 여러 개를 구현할 때는 &기호로 연결.

- 와일드 카드

static Jucie makeJucie(FruitBox box) {
    ...
}
static Jucie makeJucie(FruitBox box) {
    ...
}

⚠️ 위와 같이 오버로딩 하면 컴파일 에러가 발생한다. 제네릭 타입이 다른 것만으로는 오버로딩(new)이 성립하지 않는다. 위는 '메서드 중복 정의'이다.

----> "와일드 카드(?)" 고안

: 와일드카드 상한 제한 (T와 그 자손들) : 와일드카드 하한 제한 (T와 그 조상들) : 제한 없음. 모든 타입 가능 ( = )

- 제네릭 메서드

메서드의 선언부에 제네릭 타입이 선언된 메서드를 제네릭 메서드라 한다.

static  void sort (List list, Comparator c)

클래스의 타입변수와 메서드의 타입변수는 완전히 별개의 것이다.

static 멤버에는 타입 매개변수를 사용할 수 없지만, 메서드에 제네릭 타입을 선언하고 사용하는 것은 가능하다.

복잡하게 선언된 제네릭 메서드

  public static > void sort (List list)

  // ⬇️ List 의 요소가 Comparable인터페이스를 구현한 것이어야 한다.
  public static > void sort (List list)

타입 T를 요소로 하는 List를 매개변수로 허용한다.
'T'는 Comparable을 구현한 클래스여야 하며 'T' 또는 그 조상의 타입을 비교하는 Comparable이어야 한다.

📌 2. 열거형(enums)

👉🏻 열거형(enums)이란? JDK1.5부터 새로 추가되었다. 열거형이 갖는 값뿐만 아니라 타입까지 관리. (타입에 안전한 열거형) : 실제 값이 같아도 타입이 다르면 조건식의 결과가 false가 된다.

모든 열거형의 조상은 java.lang.Enum 이다.

class Card{
    static final int CLOVER = 0;
    static final int HEART= 1;
    static final int DIAMOND = 2;
    static final int SPADE = 3;

    static final int TWO = 0;
    static final int THREE = 1;
    static final int FOUR = 2;

    final int kind;
    final int num;
}

⬇️ 열거형으로

class Card{
    // 정의 : enum 열거형이름 { 상수명1, 상수명2, ... }
    enum Kind    { COLVER, HEART, DIAMOND, SPADE }
    enum Value    { TWO, THREE, FOUR }

    final Kind kind;    // type이 int가 아님에 유의
    final Value value;
}

if(Card.Kind.CLOVER == Card.Value.TWO)    // false. 타입이 다르기 때문.

== 사용 가능 (static 상수의 값이 객체의 주소이고 이 값은 바뀌지 않기 때문)
비교연산자 사용 불가능 ( -> compareTo() 사용 )
switch문의 조건식에도 열거형 사용
열거형 상수 하나하나가 객체이다.

- 열거형에 멤버 추가

enum Direction { 
    EAST(1), SOUTH(5), WEST(-1), NORTH(10);

    private final int value;    // 정수를 저장할 필드(인스턴스 변수) 추가
    Direction(int value) { this.value = value; }    // 생성자

    public int getValue() { return value; }    // 외부 접근을 가능하게 한다.
}

열거형의 생성자는 묵시적으로 private이다.

- 열거형에 추상 메서드 추가하기

열거형에 추상메서드를 선언하면 각 열거형 상수가 이 추상메서드를 반드시 구현해야 한다.

📌 3. 애너테이션(annotation)

👉🏻 애너테이션(annotation)이란? 애너테이션의 뜻은 주석, 주해, 메모이다. 미리 정의된 @태그들을 이용해서 주석 안에 정보를 저장하고, javadoc.exe라는 프로그램이 이를 읽어서 문서를 작성하는데 사용한다. 👉🏻 이를 이용하여 소스코드 안에 다른 프로그램을 위한 정보를 미리 약속된 형식으로 포함시킨 것이 애너테이션이다.

JDK에서 제공하는 애너테이션은 java.lang.annotation 패키지에 포함되어 있다.

📖 표준 애너테이션

자바에서 기본적으로 제공하는 애너테이션은 몇 개 없다. 그나마 이들의 일부는 메타 애너테이션으로, 애너테이션을 정의하는데 사용되는 애너테이션의 애너테이션이다.

애너테이션	설명
@Override	컴파일러에게 오버라이딩하는 대상이라는 것을 알린다.
@Deprecated	앞으로 사용할 것을 권장하는 대상에 붙인다.
@SuppressWarning	컴파일러의 특정 경고가 나타나지 않게 해준다.
@FunctionalInterface	함수형 인터페이스라는 것을 알린다.
@SafeVarargs	제네릭스 타입의 가변인자에 사용.
@Native	native메서드에서 참조되는 상수 앞에 붙인다.

@Override

컴파일러가 같은 이름의 메서드가 조상에 있는지 확인하고 없으면 에러 메세지를 출력한다. 이는 알아내기 어려운 실수를 미연에 방지해주므로 반드시 붙이는 것이 좋다.

📖 메타 애너테이션

애너테이션을 위한 애너테이션으로, 애너테이션을 정의할 때 애너테이션 적용대상(target)이나, 유지기간(retention)을 지정하는데 사용된다.

애너테이션	설명
@Target	애너테이션이 적용가능한 대상을 지정하는데 사용
@Documented	애너테이션 정보가 작성된 문서에 포함되게 한다.
@Inherited	애너테이션이 자손 클래스에 상속되도록 한다.
@Retention	애너테이션이 유지되는 범위를 지정하는데 사용.
@Repeatable	애너테이션을 반복해서 적용 가능하게 한다.

[Java] Ch.11 컬렉션 프레임워크

Fri, 12 Jul 2024 06:40:34 GMT

👉🏻 이 글은 자바의 정석(3판) Chapter.11을 공부하고 적은 내용입니다.

📌 컬렉션 프레임워크

컬렉션 : 다수의 데이터(데이터 그룹)
프레임워크 : 표준화된 프로그래밍 방식

➡️ 컬렉션 프레임워크 : 데이터 군을 다루고 표현하기 위한 단일화된 구조, 컬렉션과 다수의 데이터를 다루는 데 필요한 다양하고 풍부한 클래스들을 제공

JDK1.2 이전까지의 컬렉션 클래스 - Vector, Hashtable, Properties, Stack JDK1.2 이후부터 컬렉션 프레임워크 등장 - ArrayList, LinkedList, HashSet, ......

cf) JDK1.5부터 Iterable 인터페이스 추가

📖 핵심 인터페이스

컬렉션 데이터 그룹을 크게 3타입이 존재한다고 인식하고 인터페이스 정의

인터페이스	구현 클래스	특징
List	ArrayList, LinkedList, Stack, Vector 등	순서가 있는 데이터의 집합. 데이터 중복을 허용.
Set	HashSet, TreeSet 등	순서를 유지하지 않는 데이터의 집합. 데이터 중복을 허용하지 않는다.
Map	HashMap, TreeMap, Hashtable, Properties 등	키(key)와 값(value)의 쌍(pair)으로 이루어진 데이터의 집합. 순서유지X, 키는 중복을 허용하지 않는다. (Map : 어떤 두 값을 연결한다.)

⚠️ Vector나 Hashtable과 같은 기존 컬렉션들은 호환을 위해 남겨두었지만 가능하면 사용하지 않는 것이 좋다. (-> ArrayList, HashMap 사용 권장)

⭐ Collection 인터페이스

List와 Set의 부모클래스로, 두 클래스의 공통된 부분을 뽑아 정의한 것이다.

Collection 인터페이스는 컬렉션 클래스에 저장된 데이터를 읽고, 추가, 삭제하는 등 컬렉션을 다루는데 가장 기본적인 메소드들을 저장하고 있다.

메서드	설명
`boolean add(Object o)`	지정된 객체(o) 또는 Collection(c)의 객체들을 Collection에 추가한다.
`boolean addAll(Collection c)`
`void clear()`	Collection의 모든 객체를 삭제한다.
`boolean contains(Object o)`	지정된 객체(o) 또는 Collection의 객체들(c)이 Collection에 포함되어 있는지 확인한다.
`boolean containsAll(Collection c)`
`boolean equals(Object o)`	동일한 Collection인지 비교한다.
`int hashCode()`	Collection의 hash code를 반환한다.
`boolean isEmpty()`	Collection이 비어있는지 확인
`Iterator iterator()`	Collection의 Iterator를 얻어서 반환한다.
`boolean remove(Object o)`	지정된 객체를 삭제한다.
`boolean removeAll(Colection c)`	지정된 Collection에 포함된 객체들을 삭제한다.
`boolean retainAll(Collection c)`	지정된 Collection에 포함된 객체만을 남기고 다른 객체들은 Collection에서 삭제한다. 이 작업으로 인해 Collection에 변화가 생기면 true, 없으면 false를 반환한다.
`int size()`	Collection에 저장된 객체의 개수를 반환한다.
`Object[] toArray()`	Collection에 저장된 객체를 객체배열(Object[])로 반환한다.
`Object[] toArray(Object[] a)`	지정된 배열에 Collection의 객체를 저장해서 반환한다.

⚠️ Collection은 인터페이스이고, Collections는 클래스이다.

📌 List

📖 List 인터페이스

중복을 허용하면서 저장순서가 유지되는 컬렉션을 구현하는데 사용한다.

⭐ ArrayList

ArrayList는 List인터페이스를 구현하기 때문에 데이터의 저장순서 유지, 중복 허용

기존의 Vector를 개선한것으로 Vector와 구현원리와 기능적인 측면에서 동일하다고 할 수 있다. Vector는 기존에 작성된 코드와의 호환성을 위해서 계속 남겨 두고 있을 뿐이기 때문에 가능하면 Vector보다는 ArrayList를 사용하자.

⬇️ArrayList 소스코드 일부

public class ArrayList extends AbstractList 
    implements List, RandomAccess, Cloneable, java.io.Serializable{
        ...
    transient Object[] elementData;    // Object배열
        ...
}

Object 배열을 이용해서 데이터를 순차적으로 저장한다. 선언된 배열의 타입이 Object이므로 모든 종류의 객체를 담을 수 있다.

⬇️ ArrayList의 생성자와 매서드

메서드	설명
ArrayList()	크기가 10인 ArrayList 생성
ArrayList(Collection c)	주어진 컬렉션이 저장된 ArrayList를 생성
ArrayList(int initialCapacity)	지정된 초기용량을 갖는 ArrayList 생성
Object clone()	ArrayList를 복제한다.
void ensureCapacity(int minCapacity)	ArrayList의 용량이 최소한 minCapacity가 되도록 한다.
List subList(int fromIndex, int toIndex)	fromIndex부터 toIndex 사이에 저장된 객체를 반환한다.
Object[] toArray()	ArrayList에 저장된 모든 객체들을 객체배열로 반환한다.
Object[] toArray(Object[] a)	ArrayList에 저장된 모든 객체들을 객체배열 a에 담아 반환한다.
void trimToSize()	용량을 크기에 맞게 줄인다.(빈 공간을 없앤다.)
...

⬇️ 아래는 list2에서 list1과 공통되는 요소들을 찾아 삭제하는 부분이다.

for(int i=list2.size()-1; i>=0; i--) {
    if(list1.contains(list2.get(i));
        list2.remove(i);
}

⚠️ 만일 변수 i를 증가시켜가면서 삭제하면, 한 요소가 삭제될 때마다 빈 공간을 채우기 위해 나머지 요소들이 자리이동을 하기 때문에 올바른 결과를 얻을 수 없다. 그래서 제어변수를 감소시켜가며 삭제를 해야 자리이동이 발생해도 영향을 받지 않고 작업이 가능하다.

⚠️ ArrayList를 생성할 때, 저장할 요소의 개수를 고려해서 실제 저장할 개수보다 약간 여유있는 크기로 하는 것이 좋다.

    List list = new ArrayList(length/LIMIT +10);

생성할 때 지정한 크기보다 더 많은 객체를 저장하면 자동적으로 크기가 늘어나기는 하지만 이 과정에서 처리시간이 많이 소요되기 때문이다.

Vector의 용량과 크기에 관한 코드

class VectorEx1{
    public static void main(String[] args) {
            Vector v = new Vector(5);
            v.add("1");
            v.add("2");
            v.add("3");
            print(v);

            v.trimToSize();    // 빈 공간을 없앤다. (용량과 크기가 같아진다.)
            System.out.println("=== After trimToSize() ===");
            print(v);

            v.ensureCapacity(6);
            System.out.println("=== After ensureCapacity(6) ===");
            print(v);

            v.setSize(7);
            System.out.println("=== After setSize(7) ===");
            print(v);

            v.clear();
            System.out.println("=== After clear() ===");
            print(v);
        }

    public static void print(Vector v) {
            System.out.println(v);
            System.out.println("size :"+v.size());
            System.out.println("capacity :"+v.capacity());
            System.out.println();
    }
}

--> 배열은 크기를 변경할 수 없기 때문에 새로운 배열을 생성해서 그 주소값을 변수 v에 할당한다. 기존의 Vector 인스턴스는 더 이상 사용할 수 없으며, 후에 가비지 컬렉터에 의해 메모리에서 제거된다.

---> 따라서 ArrayList나 Vector과 같이 배열을 이용한 자료구조는 데이터를 읽어오고 저장하는 데는 효율이 좋지만 (접근 시간, access time), 용량을 변경해야 할 때는 데이터 복사 과정을 거치기 때문에 상당히 효율이 떨어진다.

----> 처음에 인스턴스를 생성할 때 저장할 데이터의 개수를 잘 고려해서 충분한 용량의 인스턴스를 생성하는 것이 좋다. (이 방법을 이용할 시, 메모리 낭비 가능성이 있는 것이 배열의 단점임.)

⭐ LinkedList

위의 배열의 단점을 보완하기 위해 LinkedList라는 자료구조가 고안됨. 배열은 모든 데이터가 연속적으로 존재하지만 링크드 리스트는 불연속적으로 존재하는 데이터를 서로 연결한 형태로 구성되어 있다.

링크드 리스트의 각 요소(node)들은 자신과 연결된 다음 요소에 대한 참조(주소값)와 데이터로 구성되어 있다.

class Node {
    Node next;        // 다음 요소의 주소를 저장
    Object obj;        // 현 노드의 데이터 저장
}

- 요소 삭제 & 추가

삭제 : 삭제하고자 하는 요소의 이전 요소가 삭제하고자 하는 요소의 다음 요소를 참조하도록 변경하기만 하면 된다.
추가 : 새로운 요소를 생성한 다음 추가하고자 하는 위치의 이전 요소의 참조를 새로운 요소에 대한 참조로 변경, 새로운 요소가 그 다음 요소를 참조하도록 변경.

이동방향이 단방향 -> 이전요소에 대한 접근은 어려움 --> 더블 링크드 리스트

- 더블 링크드 리스트 (이중 연결리스트)

: 양방향 가능하도록 앞뒤 연결

class Node {
    Node next;        // 다음 요소의 주소를 저장
    Node previous;    // 이전 요소의 주소를 저장
    Object obj;        // 현 노드의 데이터 저장
}

⬇️ 접근성을 더욱 향상시킨 것

- 더블 써큘러 링크드 리스트(이중 원형 연결리스트)

: 첫 번째 요소와 마지막 요소를 서로 연결시킨 것.

LinkedList 역시 List인터페이스를 구현했기 때문에 ArrayList와 내부구현방법만 다를뿐 제공하는 메서드의 종류와 기능은 거의 같다.

⭐ Stack과 Queue

Stack : 마지막에 저장한 데이터를 가장 먼저 꺼내는 LIFO구조 (동전통 구조) Ex) 수식계산, 수식 괄호 검사, 웹 브라우저 뒤로/앞으로....

Stack의 메서드

메서드	설명
boolean empty()	Stack이 비어있는지 알려준다.
Object peek()	맨 위에 있는 객체를 반환. pop과 달리 객체를 꺼내지는 않음. (비었을 경우 EmptyStackException 발생함)
Object pop()	맨 위에 저장된 객체를 꺼낸다. (비었을 경우 EmptyStackException 발생함)
Object push(Object item)	Stack에 객체를 저장한다.
int search(Object o)	주어진 객체를 찾아서 그 위치를 반환. 못 찾으면 -1 반환. (배열과 달리 위치는 1부터 시작)

Queue : 처음에 저장한 데이터를 가장 먼저 꺼내는 FIFO구조 (파이프 구조) Ex) 최근 사용 문서, 인쇄작업 대기 목록, 버퍼(buffer)....

Queue의 메서드

메서드	설명
boolean add(Object o)	지정된 객체를 Queue에 추가한다. 성공하면 true, 저장공간이 부족하면 IllegalStateException발생
Object remove()	객체를 꺼내 반환. 비어있으면 NoSuchElementException 발생
Object element()	삭제 없이 요소를 읽어온다. peek와 달리 Queue가 비어있을 때 NoSuchElementException 발생
Object offer(Object o)	Queue에 객체를 저장. 성공하면 true, 실패하면 false
Object poll()	Queue에서 객체를 꺼내 반환. 비어있으면 null 반환.
Object peek()	삭제 없이 요소를 읽어 온다. Queue가 비어있으며 null을 반환

👉🏻 Queue의 인터페이스 기능 사용할 때 아래의 Java API문서 참고 https://docs.oracle.com/javase/8/docs/api/java/util/Queue.html

PriorityQueue : Queue의 구현체 중 하나, 저장한 순서와 관계없이 우선순위가 높은 것부터 꺼내는 특징이 있다. ( null은 저장할 수 없다. ) 저장공간으로 배열을 사용, 각 요소를 힙이라는 자료구조 형태로 저장.
Deque 덱, 다큐 (Double-Ended Queue) : Queue의 변형. 양쪽 끝에 추가/삭제가 가능하다. Deque의 조상은 Queue, 구현체는 ArrayDeque, LinkedList 스택과 큐를 하나로 합쳐 놓은 것과 같다.

Deque	Queue	Stack
offerLast()	offer()	push()
pollLast()	-	pop()
pollFist()	poll()	-
peekFirst()	peek()	-
peekLast()	-	peek()

📖 Enumeration, Iterator, ListIterator

모두 컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스이다. Enumeration은 Iterator의 구버전이며, ListIterator는 Iterator의 기능을 향상시킨 것이다.

⭐ Iterator

public interface Iterator{
    boolean hashNext();        // 읽어 올 요소가 남아있는지 확인한다.
    Object next();            // 다음 요소를 읽어 온다.
    void remove();            // next()로 읽어 온 요소를 삭제. (선택적 기능)
}

public interface Collention {
    ...
    public Iterator iterator();        // List와 Set에서도 포함되어 있음.
    ...
}

// 리스트에 저장된 요소들을 출력하기 위한 코드
List list = new ArrayList(); // 다른 컬렉션으로 변경할 때는 이 부분만 고치면 된다.
Iterator it = list.iterator();

while(it.hashNext()) {
    System.out.println(it.next());
}

// Map인터페이스에서 Iterator 사용.
Map map = new HashMap();
    ...
    // 키와 값을 Set형태로 받아온 다음 iterator() 호출
    Iterator it = map.keySet().iterator();        // 키를 Set형태로 받아옴
    Iterator list = map.entrySet().iterator();    // 값를 Set형태로 받아옴

⭐ Enumeration

컬렉션 프레임워크가 만들어지기 전 기능으로, Iterator의 구버전임. 메서드 이름만 다를 뿐 기능은 같다.

boolean hashMoreElements() : 읽어 올 요소가 남아있는지 확인 ( = hasNext() )
Object nextElement() : 다음 요소를 읽어온다. ( = next() )

⭐ ListIterator

Iterator를 상속받아서 기능을 추가한 것으로, ListIterator는 양방향으로의 이동이 가능하다. 다만, ArrayList나 LinkedList와 같이 List인터페이스를 구현한 컬렉션에서만 사용할 수 있다.

add(Object o), hasNext(),hasPrevious(), next(), previous(), nextIndex(), remove(), set(Object o) 가 메서드로 있음.

이동하기 전에 반드시 hasNext()나 hasPrevious()를 호출해서 이동할 수 있는지 확인해야 한다.

ListIterator it = list.listIterator();

while(it.hasNext()) {        // 순방향으로 진행하면서 읽어옴
    System.out.println(it.next());
}

while(it.hasPrevious()) {    // 역방향으로 진행하면서 읽어옴
    System.out.println(it.previous());
}

remove()는 단독으로 쓰일 수 없고, next()를 호출하여 읽어온 것을 삭제하는 역할을 한다. (읽어온 값이 있어야 호출될 수 있다.)

📖 Arrays

Arrays 클래스에는 배열을 다루는데 유용한 메서드(모두 static메서드)가 정의되어 있다.

1. 배열의 복사 - copyOf(), copyOfRange()

copyOf()는 배열 전체 복사, copyOfRange()는 일부를 복사하여 새로운 배열을 만든 다음 반환한다.

int[] arr = {0, 1, 2, 3, 4};

int[] arr1 = Arrays.copyOf(arr, arr.length);
int[] arr2 = Arrays.copyOf(arr, 3);    // [0,1,2]
int[] arr3 = Arrays.copyOf(arr, 7);    // [0,1,2,3,4,0,0]
int[] arr4 = Arrays.copyOfRange(arr, 2, 4);    // [2,3]

2. 배열 채우기 - fill(), setAll()

Arrays.fill(arr, 9); : 배열의 모든 요소를 9로 채움.
Arrays.setAll(arr, ()->(int)(Math.random()*5)+1); : 배열을 채우는데 사용할 함수형 인터페이스를 매개변수로 받는다. // arr = [1,5,2,1,1]

3. 배열 정렬과 검색 - sort(), binarySearch()

sort() : 배열을 정렬
binarySearch() : 배열에서 지정된 값이 저장된 위치를 찾아서 반환

'순차검색(linear search)'보다 큰 배열의 검색에서 유리하다. 단, 배열이 정렬되어 있는 경우에만 사용할 수 있다는 단점이 있다.

4. 문자열 비교와 출력 - equals(), toString()

일차원 배열에서의 문자열로 출력은 toString()이용하고, 다차원 배열에서의 문자열로 출력은 deepToString()을 이용한다.

일차원 배열에서 배열 비교는 equals(), 다차원 배열에서 배열 비교는 deepEquals()

📌 Set

📖 Comparator와 Comparable

모두 인터페이스로 컬렉션을 정렬하는데 필요한 메서드를 정의하고 있음.
Comparable : 기본 정렬기준을 구현하는데 사용. (기본 오름차순) Comparator : 기본 정렬기준 외에 다른 기준으로 정렬하고자할 때 사용

// java.util
public interface Comparator {
    int compare(Object o1, Object o2);
    boolean equals(Object obj);
}
// java.lang
public interface Comparable {
    public int compareTo(Object o);
}

📖 HashSet

HashSet은 Set인터페이스를 구현한 가장 대표적인 컬렉션이며, 중복요소를 저장하지 않는다. 새로운 요소를 추가할 때는 add메서드나 addAll메서드를 이용하는데, 만일 이미 저장되어 있는 요소이면, false를 반환한다. 저장순서를 유지하지 않으므로 저장순서를 유지하고자 한다면 LinkedHashSet을 사용해야한다.

객체의 타입이 다르면 중복으로 간주하지 않는다. ("1") != Integer(1)

랜덤으로 중복되지 않는 숫자 배열을 만드는 방법

  for(int i=0; set.size() < 25; i++){
      set.add((int)Math.random()*50)+1+"");
  }

여러번 생성된 동일한 값의 객체를 같은 것으로 인식하게 하는 방법

  class Person{
      String name;
      int age;

      Person(String name, int age){
          this.name = name;
          this.age = age;
      }

      // 
      public boolean equals(Object obj) {
          if(obj instanceof Person){
              Person tmp = (Person)obj;
              return name.equals(tmp.name) && age==tmp.age;
          }
          return false;
      }

      public int hashCode() {
          return (name+age).hashCode();
      }

      public String toString(){
          return name + ":" + age;
      }
  }

👉🏻 HashSet의 add메서드는 새로운 요소를 추가하기 전에 기존에 저장된 요소와 같은 것인지 판단하기 위해 추가하려는 요소의 equals()와 hashCode()를 호출하므로 목적에 알맞게 오버라이딩 해야한다.

String은 문자열의 내용으로 해시코드를 만들어 내고, Object클래스는 객체 주소로 해시코드를 만들어 낸다.

📖 TreeSet

이진 검색 트리라는 자료구조의 형태로 데이터를 저장한다. 정렬, 검색, 범위 검색에 높은 성능을 보인다. 중복된 데이터의 저장을 허용하지 않으며, 정렬된 위치에 저장하므로 저장순서를 유지하지도 않는다.

이진 검색 트리 (binary tree)

모든 노드는 두 개의 자식 노드를 가질 수 있다.
왼쪽 노드는 부모노드의 값보다 작고, 오른쪽 노드는 크다.
노드의 추가, 삭제에 시간이 걸린다.
(범위)검색과 정렬에 유리하다.
중복된 값은 저장하지 못한다.

TreeSet에서의 랜덤으로 숫자 배열하기

  for(int i=0; set.size() < 6; i++) {
      int num = (int)(Math.random()*45) + 1;
      set.add(num);
  }

TreeSet은 HashSet과 달리 따로 정렬할 필요가 없다.

headSet() : 지정된 기준 값보다 큰 값의 객체들 tailSet() : 지정된 기준 값보다 작은 값의 객체들

📌 Map

📖 HashMap

Hashtable은 HashMap의 구버전. 새로운 버전인 HashMap 사용할 것을 권장한다.

Map은 키(key)와 값(value)을 묶어서 하나의 데이터(entry)로 저장한다.

public class HashMap extends AbstractMap implements Map,
Cloneable, Seialization {
    transient Entry[] table;
        ...
    static class Entry implements Map.Entry {
        final Object key;
        Object value;
        ...
    }
}

key : 컬렉션의 내의 키 중에서 유일해야 한다. value : 키와 달리 데이터의 중복을 허용. ( null 허용 ) entry = (Object, Object)

📖 TreeMap

이진 검색 트리 형태로 키와 값의 쌍을 저장한다. 검색과 정렬에 적합한 컬렉션 클래스이다.

검색에 관한한 대부분의 경우에서 TreeMap보다 HashMap이 더 뛰어나므로 HashMap을 사용하는 것이 적합하다.

다만, 범위검색이나 정렬이 필요한 경우 TreeMap을 사용하자.

📖 Properties

Hashtable을 상속받음. entry = (String, String) 주로 환경설정 관련한 속성을 저장할 때 사용한다.

📌 컬렉션 클래스 정리 & 요약

총정리 필기본

[Java] Ch.10 날짜와 시간&형식화

Sun, 07 Jul 2024 14:06:27 GMT

👉🏻 이 글은 자바의 정석(3판) Chapter10을 공부하며 쓴 글입니다.

📌 1. 날짜와 시간

📖 1.1 Calender와 Date

java.util.Date 날짜와 시간을 다룰 목적으로 만들어진 클래스(JDK1.0) 사용X
java.util.Calendar Date클래스를 개선한 새로운 클래스(JDK1.1) 여전히 단점 존재
java.time패키지 Date, Calendar의 단점 개선.(JDK1.8) 날짜와 시간을 따로 다룰 수 있도록 함. -> LocalDate / LocalTime / LocalDateTime

Calender 클래스

추상 클래스이므로 getInstance()를 통해 구현된 객체를 얻어야 한다.

Calendar cal = cal new Calendar();    //Error! 추상클래스는 인스턴스 생성 불가
Calendar cal = Calendar.getInstance();    // Calendar클래스를 구현한 클래스의 인스턴스 반환

get()으로 날짜와 시간 필드 가져오기 int get(int field) ⬇️ int field

날짜

필드명	설명
YEAR	년
MONTH	월 (0부터 시작)
WEEK_OF_YEAR	일
WEEK_OF_MONTH	그 달의 몇 번째 주
DATE	일
DAY_OF_MONTH	그 달의 몇 번째 일
DAY_OF_YEAR	그 해의 몇 번째 일
DAY_OF_WEEK	요일
DAY_OF_WEEK_IN_MONTH	그 달의 몇 번째 요일

시간

필드명	설명
HOUR	시간(0~11)
HOUR_OF_DAY	시간(0~23)
MINUTE	분
SECOND	초
MILLISECOND	천분의 일초
ZONE_OFFSET	GMT기준 시차(밀리세컨 단위)
AM_PM	오전/오후

set()으로 날짜와 시간 지정하기

void set(int field, int value)
void set(int year, int month, int date)

Calendar date1 = Calendar.getInstance(); date1.set(2017, 7, 15); //2017.08.15

⚠️월(MONTH)이 **0**부터 시작한다는 점 주의!

- 시간 지정
```java
time1.set(Calendar.HOUR_OF_DAY, 10);
time1.set(Calendar.MINUTE, 20);
time1.set(Calendar.SECOND, 30);    // 10시 20분 30초

clear()는 Calendar객체의 모든 필드를 초기화
clear(int field)는 Calendar객체의 특정 필드를 초기화
add()는 특정 필드의 값을 증가 또는 감소(다른 필드에 영향 O) : 여기서 다른 필드에 영향을 준다는 것을 8월 31일에서 date.add(Calendar.Date, 1)을 하면 자동으로 9월 1일이 되는 것을 의미
roll()은 특정 필드의 값을 증가 또는 감소(다른 필드에 영향 X)

Date <-> Calendar 간의 변환

Calendar -> Date

 Calendar cal = Calendar.getInstance();
 ...
 Date d = new Date(cal.getTimeInMillis());    // Date(long date)

Date -> Calendar

 Date d = new Date();
 ...
 Calendar cal = Calender.getInstance();
 cal.setTime(d);

📌 2.형식화 클래스

java.text 패키지의 DecimalFormat, SimpleDateFormat

숫자와 날짜를 원하는 형식으로 쉽게 출력 가능 (숫자, 날짜 -> 형식 문자열)
형식 문자열에서 숫자와 날짜를 뽑아내는 기능

📖 2.1 DecimalFormat

숫자를 형식화할 때 사용(숫자 -> 형식 문자열)
```
double number = 1234567.89;
DecimalFormat df = new DecimalFormat("#.#E0");
String result = df.format(number);    //result = "1.2E6"
```
0 : 10진수(값이 없을 때는 0) # : 10진수(값이 없으면 생략) E : 지수기호
특정 형식의 문자열을 숫자로 변환할 때도 사용(형식 문자열 -> 숫자) + ) Integer.parseInt()는 콤마(,)가 포함된 문자열을 숫자로 변환 못함.
```
DecimalFormat df = new DecimalFormat("#,###.##");
Number num = df.parse("1,234,567.89");
double d = num.doubleValue();    // 1234567.89
```

📖 2.2 SimpleDateFormat

날짜와 시간을 다양한 형식으로 출력할 수 있게 해준다.

Date today = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");

String result = df.format(today);

G : 연대(BC, AD)
y : 년도
M : 월
W : 년의 몇 번째 주 (1~53)
w : 월의 몇 번째 주 (1~5)
D : 년의 몇 번째 일 (1~366)
d : 월의 몇 번째 일 (1~31)
F : 월의 몇 번째 요일 (1~5)
E : 요일

- 특정 형식으로 되어 있는 문자열에서 날짜와 시간을 뽑아낼 수도 있다.
```java
Date d = df.parse("2015년 11월 23일");    // 문자열을 Date로 변환
String result = df2.format(d);    // format 변경