흑임자

[ERROR] gradle - java version

기넌 — Sun, 9 Jun 2024 20:39:56 +0900

환경

IntelliJ
Gradle 3.3.0
Java 21

에러

Project 설정은 모두 자바 21 버전으로 바꿨는데 인식을 못했던 문제

intellij 에서 A problem occurred configuring root project 'sbb'.
> Could not resolve all artifacts for configuration ':classpath'.
   > Could not resolve org.springframework.boot:spring-boot-gradle-plugin:3.3.0.
     Required by:
         project : > org.springframework.boot:org.springframework.boot.gradle.plugin:3.3.0
      > No matching variant of org.springframework.boot:spring-boot-gradle-plugin:3.3.0 was found. The consumer was configured to find a library for use during runtime, compatible with Java 11, packaged as a jar, and its dependencies declared externally, as well as attribute 'org.gradle.plugin.api-version' with value '8.7' but:
          - Variant 'apiElements' declares a library, packaged as a jar, and its dependencies declared externally:
              - Incompatible because this component declares a component for use during compile-time, compatible with Java 17 and the consumer needed a component for use during runtime, compatible with Java 11

해결

Gradle JVM 에서도 자바 버전을 21로 맞춰야한다.

Oracle21c 컨테이너 띄워 사용하기 (Mac M1)

기넌 — Sun, 2 Jun 2024 00:20:35 +0900

환경

Mac M1
Sonoma 14.0
Docker
Oracle21c

docker 설치

homebrew 사용

  cask 옵션

macOS용 GUI 애플리케이션을 설치하고 관리

brew install --cask docker

docker site

Install Docker Engine

Learn how to choose the best method for you to install Docker Engine. This client-server application is available on Linux, Mac, Windows, and as a static binary.

docs.docker.com

Colima 설치

  Colima?

최소한의 설정으로 MacOS에서 컨테이너 런타임 환경을 만들어주는 도구

brew install colima

Colima 에러

ssh 연결이 안되는 문제 .. (처음 실행 때는 연결 됐었는데)

문제 현상

➜  Caches colima start --memory 4 --arch x86_64
INFO[0000] starting colima
INFO[0000] runtime: docker
INFO[0002] starting ...                                  context=vm
> [hostagent] Waiting for the essential requirement 1 of 4: "ssh"
...
영원히 ssh 준비만 하고 실행이 안됨

기존에 남아있던 colima 설정 모두 삭제

colima delete -f
colima prune -a
rm -rf ~/.colima-*

추가로 colima 재설치하려면

brew uninstall colima
rm -rf ~/Library/Caches/Homebrew
brew install colima

vm-type 옵션 추가

https://github.com/abiosoft/colima/issues/913

기본으로 QEMU 드라이버를 사용하는데, 다른 드라이버로 변경

colima start --memory 4 --arch x86_64 --vm-type vz

Result

➜  ~ colima start --memory 4 --arch x86_64 --vm-type vz

INFO[0000] starting colima                              
INFO[0000] runtime: docker                              
INFO[0001] creating and starting ...                     context=vm
INFO[0186] provisioning ...                              context=docker
INFO[0187] starting ...                                  context=docker
INFO[0193] done

Oracle21c 컨테이너 실행

docker run --restart unless-stopped --name oracle21 -e ORACLE_PASSWORD={DB 접속 비밀번호} -p {호스트 운영체제의 포트번호}:{컨테이너 내부에서의 포트번호 - 1521} -d gvenzl/oracle-xe

참고

[Mac] M1 맥북에서 Oracle 11 사용하기

프로세스와 스레드

기넌 — Wed, 7 Feb 2024 00:22:09 +0900

막연하게 프로세스는 프로그램이 메모리에 올라가서 실행 중인 상태,
스레드는 프로세스의 하나의 실행 단위 라고 생각해왔다.
동기화나 세마포어, 뮤텍스 .. 등을 다시 한번 되짚어보며 정리의 필요성을 느꼈다.

Program

어떤 작업을 위해 실행할 수 있는 파일

Process

컴퓨터에서 연속적으로 실행되고 있는 컴퓨터 프로그램

메모리 에 올라와 실행되고 있는 프로그램의 인스턴스

운영체제로부터 시스템 자원을 할당받은 작업의 단위

메모리 에 올라와 실행된 프로그램

할당받는 시스템 자원의 예

CPU 시간
운영되기 위해 필요한 주소 공간
Code, Data, Stack, Heap 의 구조로 되어있는 독립된 메모리 영역

프로세스의 독립된 메모리 영역

기본적으로 프로세스당 최소 1개의 스레드 (메인 스레드)를 가지고 있다.
각 프로세스는 별도의 주소 공간 에서 실행되며, 한 프로세스는 다른 프로세스의 변수나 자료구조에 접근할 수 없다.
한 프로세스가 다른 프로세스의 자원에 접근하려면 프로세스 간 통신 (IPC, inter-process communication) 이 필요하다.
- 파이프, 파일, 소켓 등을 이용한 통신 방법 이용

Thread

프로세스 내에서 실행되는 여러 흐름의 단위

프로세스가 할당받은 자원을 이용하는 실행의 단위

프로세스 내의 스레드 영역

스레드는 프로세스 내에서 Stack 만 각자 할당받고 Code, Data, Heap 영역은 공유한다.
스레드는 한 프로세스 내에서 동작되는 여러 실행의 흐름 으로, 프로세스 내의 주소 공간이나 자원들(힙 공간 등)을 같은 프로세스 내에 스레드끼리 공유 하면서 실행된다.
같은 프로세스 안에 있는 여러 스레드들은 같은 힙 공간을 공유하는 반면, 프로세스는 다른 프로세스의 메모리에 직접 접근이 불가능(통신하기 위해선 IPC를 이용 -위에서 언급-) 하다.

→ 이렇게 길게 써놓았지만 결론은

프로세스 내 Code, Data, Heap 영역은 공유 되고, Stack 만 각자 할당 받는다. 따라서 프로세스끼리는 서로의 메모리에 직접 접근이 불가하지만 한 프로세스 내의 형제 스레드(sibling thread)끼리는 Code, Data, Heap 영역은 변경 내역을 즉시 확인 할 수 있다.

`Stack` 이 독립적으로 할당되는 이유?

스택은 함수 호출 시 전달되는 인자, 되돌아갈 주소값 및 함수 내에서 선언하는 변수 등을 저장하기 위해 사용되는 메모리 공간이다.
따라서 스택 메모리 공간이 독립적이라는 것은 독립적인 함수 호출이 가능하다는 것이고, 이는 독립적인 실행 흐름이 추가되는 것이다.
결과적으로 실행 흐름의 추가를 위한 최소 조건이 독립된 스택을 제공하는 것이다.

그 이외의 영역이 공유되는 이유?

코드 영역을 공유
프로세스는 독립적인 구조이기 때문에 다른 프로세스의 Code 영역에 있는 함수를 호출할 수 없다.
스레드는 Code 영역을 공유하기 때문에 두 개 이상의 쓰레드가 자신이 포함된 프로세스의 Code 영역에 있는 함수를 호출할 수 있다.

데이터 영역과 힙 영역을 공유
전역 변수와 동적 할당된 메모리 공간을 공유할 수 있고, 이를 통해 쓰레드 간 통신을 할 수 있지만 동시에 메모리에 접근하기 때문에 주의해야 한다.

다음은 PCB(그리고 context switch)와 공유자원(임계구역) 동기화 (세마포어, 뮤텍스)에 대해 정리하겟음.

참고

https://gmlwjd9405.github.io/2018/09/14/process-vs-thread.html
https://brownbears.tistory.com/39

[JPA] M:N 관계 (@ManyToMany)

기넌 — Tue, 30 Jan 2024 20:19:53 +0900

중고책 판매 사이트 제작 프로젝트를 하던 중, 회원(User)-채팅방(Chat)의 관계를 다대다로 설정해야했다.

처음 생각했던 방법은 @ManyToMany

@ManyToMany

다대다 단방향

다대다 관계에서는 기본적으로 두 테이블 사이에 연결 테이블이 들어간다. 그 연결 테이블은 @JoinTable에서 지정해줄 수 있다.
단방향 연결은 연관 관계의 주인(User)에서 joinColumn(내 쪽에서 연결할 컬럼), inverseJoinColumn(상대 쪽에서 연결할 컬럼)을 모두 JoinTable 지정 시에 같이 설정할 수 있다.

@Entity
@Table(name = "user")
public class User {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id", nullable = false, unique = true)
  private Long userId;

  @Column(name = "username")
  private String username;

  @Column(name = "password")
  private String password;

  @ManyToMany
  @JoinTable(name = "user_chat",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "chat_id"))
  private List<Chat> chats = new ArrayList<>();
}

@Entity
@Table(name = "chat")
public class Chat {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "chat_id", nullable = false, unique = true)
  private Long chatId;
}

다대다 양방향

두 Entity가 모두 List<상대 Entity>를 갖고있다.

@Entity
@Table(name = "user")
public class User {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id", nullable = false, unique = true)
  private Long userId;

  @Column(name = "username")
  private String username;

  @Column(name = "password")
  private String password;

  @ManyToMany
  @JoinTable(name = "user_chat",
    joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "chat_id"))
  private List<Chat> chats = new ArrayList<>();
}

@Entity
@Table(name = "chat")
public class Chat {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "chat_id", nullable = false, unique = true)
  private Long chatId;

  @ManyToMany(mappedBy = "chats")
  private List<User> users = new ArrayList<>();
}

두 방법 동일하게 연결 테이블이 user_id, chat_id 하나씩 참조하게 된다.

mysql> desc user_chat;
+---------+--------+------+-----+---------+-------+
| Field   | Type   | Null | Key | Default | Extra |
+---------+--------+------+-----+---------+-------+
| user_id | bigint | NO   | MUL | NULL    |       |
| chat_id | bigint | NO   | MUL | NULL    |       |
+---------+--------+------+-----+---------+-------+
2 rows in set (0.01 sec)

@ManyToMany 한계

단순히 두 테이블의 다대다 관계를 나타내기 위한 연결 테이블을 생성하기에 각 테이블의 기본 키만 갖고있다.
그렇기 때문에 확장 가능성을 고려했을 때 좋은 선택이 아니다.
그래서 프로젝트에선 @ManyToMany 대신 연결 테이블(엔티티)을 직접 생성하고 연결 테이블과 각 테이블을 다대일 관계로 만들었다.

연결 테이블 직접 정의 후 다대일 연결(@OneToMany, @ManyToOne)

User와 Chat에 UserChat(연결 엔티티)의 리스트를 정의하고 mappedBy에는 각 엔티티의 테이블 이름(user, chat)을 지정했다.

@Entity
@Table(name = "user")
public class User {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id", nullable = false, unique = true)
  private Long userId;

  @Column(name = "username")
  private String username;

  @Column(name = "password")
  private String password;

  @OneToMany(mappedBy = "user")
  private List<UserChat> userChats = new ArrayList<>();
}

@Entity
@Table(name = "chat")
public class Chat {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "chat_id", nullable = false, unique = true)
  private Long chatId;

  @OneToMany(mappedBy = "chat")
  private List<UserChat> userChats = new ArrayList<>();
}

연결 테이블에는 각 엔티티와 다대일(@ManyToOne)로 기본키와 연결하도록 했다.

@Entity
public class UserChat {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_chat_id", nullable = false, unique = true)
  private Long userChatId;

  @ManyToOne
  @JoinColumn(name = "chat_id")
  private Chat chat;

  @ManyToOne
  @JoinColumn(name = "user_id")
  private User user;
}

연결 테이블의 기본키를 따로 둬서 복합 기본 키일때 생길 수 있는 문제점(쿼리 작성 시 복잡함 등)을 배제하고자 했다.

mysql> desc user_chat;
+--------------+--------+------+-----+---------+----------------+
| Field        | Type   | Null | Key | Default | Extra          |
+--------------+--------+------+-----+---------+----------------+
| user_chat_id | bigint | NO   | PRI | NULL    | auto_increment |
| chat_id      | bigint | YES  | MUL | NULL    |                |
| user_id      | bigint | YES  | MUL | NULL    |                |
+--------------+--------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

참고

JPA - 다대다 연관관계
[JPA] @ManyToMany와 한계점 극복

Transaction

기넌 — Thu, 18 Jan 2024 23:36:49 +0900

정의

데이터베이스의 상태를 변화시키기 위해 수행하는 작업 단위이자 한번에 모두 수행되어야하는 일련의 연산

상태를 변화 == SQL 질의어(INSERT, UPDATE, DELETE ... )를 통해 DB에 접근

트랜잭션 성질 (ACID)

Atomicity(원자성): 트랜잭션 내 연산은 모두 반영되든지(commit) 아예 하나도 반영되지 않아야한다(rollback).
Consistency(일관성): 실행이 성공적으로 완료되면 언제나 일관성있는 데이터베이스 상태를 유지해야한다.
Isolation(독립성): 둘 이상의 트랜잭션이 병행 수행될 때, 서로의 연산에 끼어들거나 영향을 주면 안된다.
Durability(영속성): 한 번 트랜잭션이 성공적으로 완료되면 해당 결과가 영구적으로 저장되어야한다.

Consistency는 트랜잭션의 일관성을 보장, Durability는 트랜잭션의 결과가 영구적으로 저장되고 시스템 장애에도 안전하게 유지되는 것

연산 및 상태

commit: 하나의 트랜잭션이 성공적으로 끝났고, DB가 일관성있는 상태일 때 이를 알려주기 위해 사용하는 연산

rollback: 트랜잭션 처리가 비정상적으로 수행되어 트랜잭션 원자성이 깨진 경우, 트랜잭션 내 연산을 모두 취소하고 트랜잭션을 수행하기 전 상태로 되돌려놓는 연산

Active(활동): 트랜잭션 실행 중인 상태
Failed(실패): 트랜잭션 실행 중 오류가 발생해 중단된 상태
Aborted(철회): 트랜잭션이 비정상적으로 처리되어 rollback 연산을 수행한 상태
Partially Committed(부분 완료): 트랜잭션 마지막 연산까지 정상적으로 처리되었지만 아직 commit은 하지 않은 상태
Committed(완료): 트랜잭션이 성공적으로 종료되어 Commit 연산을 실행한 후의 상태

사용 예제

MySQL

-- 트랜잭션 시작
START TRANSACTION;

-- 예제를 위한 테이블 생성
CREATE TABLE account (
    id INT PRIMARY KEY,
    balance DECIMAL(10,2)
);

CREATE TABLE transaction_log (
    id INT PRIMARY KEY,
    account_id INT,
    amount DECIMAL(10,2),
    timestamp TIMESTAMP
);

-- 트랜잭션 내에서 에러 발생 시
BEGIN
    -- 사용자 계좌에 돈을 입금하는 SQL 문장
    UPDATE account SET balance = balance + 1000 WHERE id = 1;

    -- 트랜잭션 로그에 입금 내역을 기록하는 SQL 문장
    INSERT INTO transaction_log (account_id, amount, timestamp) VALUES (1, 1000, NOW());

    -- 여기서 의도적으로 에러 발생 (예: 나누기 0)
    SELECT 1 / 0;

    -- 에러가 발생하지 않았다면 트랜잭션 커밋
    COMMIT;
-- 트랜잭션 롤백
ROLLBACK;
END;

출처

gyoogle.dev - tech interview
coding-factory.tistory.com

index

기넌 — Mon, 8 Jan 2024 05:16:58 +0900

정의; DB에서 index란?

추가적인 쓰기 작업과 저장 공간을 활용해 데이터베이스 테이블의 특정 열(데이터)에 대한 검색 속도를 향상시키기 위해 사용되는 데이터 구조

사용 목적

왜?

정의에 나온 것처럼 자주 찾는 데이터의 검색 속도를 향상시키기 위함이다.

언제?

규모가 작지 않은 테이블
INSERT, UPDATE, DELETE가 자주 발생하지 않은 컬럼
JOIN, WHERE 또는 ORDER BY 에 자주 사용되는 컬럼
기본적으로 B 트리로 구현되어있어 정렬되어있다는 전제 하에 이루어지는 이야기
- 범위 검색이 필요할 때
- 정렬이 필요할 때

장단점

장점

인덱스에 기록된 데이터에 대한 검색 속도가 향상한다.
동일하게 조회를 사용하는 UPDATE, DELETE의 성능이 향상된다.

단점

일정 공간, 일반적으로 DB의 약 10%에 해당하는 공간을 사용해야한다.
따라서 색인해놓는 데이터가 많아질 수록 인덱스 테이블 크기가 커진다.
검색(조회) 기능에서는 성능 향상을 보일 수 있으나 그 외 삽입, 수정, 삭제 시에 인덱스도 함께 업데이트되어야 하므로 자주 일어난다면 속도가 감소할 수 있다.

구현 알고리즘

Hash table

해시 테이블 기반으로 인덱스는 {해싱된 컬럼의 값, 데이터 위치} 값을 가진다.
시간복잡도는 O(1)로 빠른 검색을 지원한다.

하지만 인풋값이 1이라도 달라지는 순간 아예 다른 아웃풋을 내는 해시 함수의 특성상, 부등호 연산에는 적합하지 않다.

그래서 일반적으로 아래와 같은 알고리즘이 사용된다.

B tree

이진 트리를 확장해 하나의 노드가 가질 수 있는 자식 노드의 최대 숫자가 2보다 큰 트리 구조
DB와 파일 시스템에서 자주 사용된다.

특징

루트에서 리프까지의 거리가 모두 일정하다.
하나의 노드에 많은 수의 정보를 가질 수 있다.
노드는 최대 M개의 자식 노드를 가질 수 있다고 하면, 해당 트리는 M차 B 트리라고 한다.
M차 B 트리라고 할 때, 노드 당 키는 최대 M-1개 가질 수 있다.
각 노드는 최소 M/2 개의 자식 노드를 가진다. (루트와 Leaf 노드 제외)
각 노드는 최소 M/2 - 1 개의 key를 가진다. (루트와 Leaf 노드 제외)
항상 Leaf 노드에 데이터가 추가된다.
노드가 넘치면 가운데 Key를 기준으로 좌우 Key를 분할해 가운데 Key는 승진한다.
노드가 넘친다: 3에서 봤던 특징처럼 하나의 노드 당 최대 key 수가 정해져있는데, 이를 넘었을 때 노드가 넘친다고 한다.

B+ tree

B 트리의 변형된 형태로, leaf 노드에만 값(데이터)이 저장이 되고 그 윗 노드들은 키와 포인터로만 구성되어 인덱스 역할을 수행한다.
모든 노드가 같은 레벨에 대해 정렬된 키값을 가지고 있다.

연결 리스트
B 트리 때 탐색을 위해 노드를 찾아서 이동해야한다는 단점을 보완하기 위해 leaf 노드들은 연결리스트 형태이다.
덕분에 옆에 있는 리프 노드를 다시 검색해야할 때 리프노드에서 선형 검사를 할 수 있다.
** 선형 검사: 데이터 집합에서 특정 값을 찾기 위해 처음부터 순차적으로 검색하는 방법

장점
- 루트부터 모든 리프 노드까지의 깊이가 같아서 O(log N)의 시간복잡도를 가진다.
- 데이터가 정렬된 상태로 리프 노드에 연결 리스트 구조로 저장되어있어 데이터를 재검색할 때 모든 노드를 다시 다 돌지 않아도 된다.
- 리프 노드가 연결 리스트로 구성되어있어, 선형 탐색을 지원한다.
단점
- 값(데이터)은 리프 노드에 저장하고, 그 외의 노드는 데이터의 인덱스로 사용하니 값이 많아질수록 메모리 사용량이 높아질 수 있다.

결론

요즘 사용되는 DB 인덱스는 일반적으로 B+ 트리로 구현되어있다.
그래서 B+ 트리의 특징, 장단점을 DB 인덱스가 비슷하게 가져갈 수 있다.
예를 들면, 빠른 검색 지원, 데이터를 정렬된 상태로 유지하며 범위 탐색 지원 등

출처

https://mangkyu.tistory.com/96
https://velog.io/@chanyoung1998/B%ED%8A%B8%EB%A6%AC
https://nooblette.tistory.com/entry/B-%ED%8A%B8%EB%A6%ACB-Tree
https://velog.io/@kyeun95/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-B-Tree%EB%9E%80

[Spring Security] OAuth, JWT .. 적용기 (1)

기넌 — Fri, 5 Jan 2024 00:12:49 +0900

Spring Security

회원가입, 로그인 기능과 같이 인증/인가 작업을 spring security, JWT로 처리해보기로 했다.
이전부터 OAuth 방식으로 인증, 인가를 구현해보고 싶었는데 spring security를 사용하면 filter나 authenticationProvider, manager 같은 객체 생성, 연결이 어렵지 않을 것 같았다. 그래서 도입해보기로 함.

spring security 흐름도

의존성 추가

// build.gradle
implementation 'org.springframework.boot:spring-boot-starter-security'

User

User Entity

@NoArgsConstructor
@Getter
@Entity
@Table(name = "user")
@DynamicUpdate
/* 삭제된 데이터는 가져오지 않음 */
@Where(clause = "deleted_at is NULL")
/* 삭제요청이 들어오면 실제로 데이터를 삭제하지 않고 삭제 시간을 기록한다. */
@SQLDelete(sql = "update user set deleted_at = CURRENT_TIMESTAMP where user_id = ?")
public class User extends BaseTime {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id", nullable = false)
  private Long userId;

  // 사용자 계정 ID
  @Column(name = "username", nullable = false)
  private String username;

  // 사용자 비밀번호
  @Column(name = "password", nullable = false)
  private String password;

  // 사용자 닉네임
  @Column(name = "nickname", nullable = false)
  private String nickname;

  // 사용자의 권한
  @Column(name = "roles", nullable = false, length = 30)
  private String roles;

  // roles(권한) 데이터가 여러개 있다면 ,로 이어져있어 분리 후 List 구현 객체로 반환
  public List<String> getRoleList() {
    if (this.roles != null && this.roles.length() > 0) {
      return Arrays.asList(this.roles.split(","));
    }
    return new ArrayList<>();
  }

  @Builder
  public User(String username, String password, String nickname, String roles) {
    this.username = username;
    this.password = password;
    this.nickname = nickname;
    this.roles = roles;
  }
}

PrincipalDetails

spring security에서 사용자 정보를 담은 객체

@Data
public class PrincipalDetails implements UserDetails {

  // 내가 정의한 User Entity
  private User user;

  public PrincipalDetails(User user) {
    this.user = user;
  }

  // 해당 사용자의 모든 권한 가져오기
  @Override
  public Collection<? extends GrantedAuthority> getAuthorities() {
    Collection<GrantedAuthority> authorities = new ArrayList<>();
    user.getRoleList().forEach(role -> {
      authorities.add(()  -> role);
    });;
    return authorities;
  }

  @Override
  public String getPassword() {
    return user.getPassword();
  }

  @Override
  public String getUsername() {
    return user.getUsername();
  }

  @Override
  public boolean isAccountNonExpired() {
    return true;
  }

  @Override
  public boolean isAccountNonLocked() {
    return true;
  }

  @Override
  public boolean isCredentialsNonExpired() {
    return true;
  }

  @Override
  public boolean isEnabled() {
    return true;
  }
}

PrincipalDetailsService

사용자의 정보를 가져오기 위한 UserDetailsService을 구현한 클래스로, loadUserByUsername을 오버라이딩해서 spring security가 추후 PrincipalDetails을 가져올 수 있도록 한다.

@RequiredArgsConstructor
@Slf4j
@Service // 필수로 @Service 어노테이션을 달아야한다. 아니면 Spring security가 찾지 못한다.
public class PrincipalDetailsService implements UserDetailsService {

  private final UserRepository userRepository;

  @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    log.info("[PrincipalDetailsService] loadUserByUsername {}", username);
    Optional<User> user_optional = userRepository.findByUsername(username);

    // 유저를 찾지 못하면 에러를 던진다.
    if (user_optional.isEmpty()) throw new CustomException(ErrorCode.USER_NOT_FOUND);

    return new PrincipalDetails(user_optional.get());
  }
}

Config

WebSecurityConfig

Spring security 설정 파일
~~.. jwt filter apply 수정 필요~~

CSRF(Cross Site Request Forgery Attack): 사이트 간 요청 위조, 라고 한다. 간단히 말하면 인증된 사용자가 특정 URI로 요청을 보내도록 만드는(유도하는) 공격
e.g.) 이메일이나 웹 사이트에 링크를 걸어두고, 이를 클릭하면 특정 사이트에 제품 구입, 계정 설정, 기록 삭제, 비밀번호 변경, 문자 전송 등과 같은 요청을 보내도록 하는 것
exceptionHandling(): 인증 인가 과정에서 에러가 날 떄 핸들링해주기 위한 것으로, 이어서 authenticationEntryPoint나 accessDeniedHandler를 설정해줄 수 있다.
이 외에는 주석 참고

@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig {

  private final JwtTokenProvider jwtTokenProvider;
  private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
  private final JwtAccessDeniedHandler jwtAccessDeniedHandler;

  @Bean
  public BCryptPasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
  }

  @Bean
  public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
            .csrf().disable()
            .formLogin().disable()
            .exceptionHandling()
            .authenticationEntryPoint(jwtAuthenticationEntryPoint)
            .accessDeniedHandler(jwtAccessDeniedHandler)

            .and()
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)

            .and()
            .apply(new JwtSecurityConfig(jwtTokenProvider))

            .and()
            .authorizeHttpRequests()
            // /api/user/sign-up 이나 /api/auth/login 로 들어오는 요청은 인증 및 인가가 필요 없도록
            .requestMatchers("/api/user/sign-up").permitAll()
            .requestMatchers("/api/auth/login").permitAll()
            // 그 외로 들어오는 요청은 모두 인증이 필요하다.
            .anyRequest().authenticated();

    return http.build();
  }
}

Controller 및 Service

AuthController

로그인과 같은 인증 관련 요청을 핸들링할 controller

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/auth")
@Slf4j
public class AuthController {

  // 인증 관련 서비스 로직을 다루는 authService
  private final AuthService authService;

  /* Value 값 넣을 때는 static, final 안돼 */
  @Value("${jwt.AUTHORIZATION_HEADER}")
  private String AUTHORIZATION_HEADER;

  @Value("${jwt.REFRESH_HEADER}")
  private String REFRESH_HEADER;

  private static final String PREFIX = "Bearer ";

  @PostMapping("/login")
  public ResponseEntity<Boolean> login(HttpServletResponse response, @RequestBody LoginRequestDTO request) {
    log.info("로그인 시작");
    // authService.login()에서 토큰 발급 받기
    TokenDTO tokenDTO = authService.login(request);
    // Authorization: Bearer <access token> 형식으로 헤더에 토큰 넣어 응답하기
    response.setHeader(AUTHORIZATION_HEADER, PREFIX + tokenDTO.getAccessToken());
    log.info(AUTHORIZATION_HEADER + ": " + PREFIX + tokenDTO.getAccessToken());
    // Refresh: Bearer <refresh token> 형식으로 헤더에 토큰 넣어 응답하기
    response.setHeader(REFRESH_HEADER, PREFIX + tokenDTO.getAccessToken());
    log.info(String.valueOf(response));

    // 정상적으로 토큰 발급되었다는 의미에서 true 반환
    return ResponseEntity.status(HttpStatus.OK).body(true);
  }
}

AuthService

인증, 인가 관련 서비스 로직을 담은 service

여기서 고치고 싶은건 AuthenticationManager를 여기서 buidler 로 생성하지 않고 securityConfig에서 생성한 예제를 본 것 같다. 그리고 UserDetailsService를 주입해줬던 것 같은데 .. 다시 보고 수정해야겠다.

@Service
@RequiredArgsConstructor
@Slf4j
public class AuthServiceImpl implements AuthService {

  // 인증 절차 관리하는 AuthenticationManager를 생성하는 AuthenticationManagerBuilder 객체 생성.
  private final AuthenticationManagerBuilder authenticationManagerBuilder;

  private final JwtTokenProvider jwtTokenProvider;

  @Override
  public TokenDTO login(LoginRequestDTO request) {
    // 사용자의 username, password를 기반으로 Authentication의 구현체인 UsernamePasswordAuthenticationToken 객체를 만든다.
    UsernamePasswordAuthenticationToken authenticationToken =
            new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword());
    log.info("auth token: " + authenticationToken.getName() + " " + authenticationToken.getCredentials());
    Authentication authentication = 
            authenticationManagerBuilder.getObject() // authenticationManager를 생성해
            .authenticate(authenticationToken); // authenticationToken에 대한 인증 작업을 수행한다.

    // 토큰 생성
    TokenDTO tokenDTO = jwtTokenProvider.generateToken(authentication);

    log.info("token DTO: {}", tokenDTO.toString());

    /*
    key-value 형식의 DB에 refresh token 저장해두는 코드 필요
     */

    return tokenDTO;
  }
}

JWT

JwtTokenProvider

JWT 토큰 발급 및 검증하는 객체

@Component
@Slf4j
public class JwtTokenProvider implements InitializingBean {

  @Value("${jwt.SECRET}")
  private String secret;

  private static final String AUTHORITIES_KEY = "auth";
  private static final String PREFIX = "Bearer";
  private static long ACCESS_TOKEN_EXPIRE_TIME = 1000 * 60 * 60 * 24; // 1일
  private static long REFRESH_TOKEN_EXPIRE_TIME = 1000 * 60 * 60 * 24 * 2; // 2일

  private Key key;

  @Override
  public void afterPropertiesSet() throws Exception {
    // JwtTokenProvider 빈이 생성될 떄 key값 인코딩해서 클래스 객체 key에 넣어주기
    byte[] encodedKey = Base64.getEncoder().encode(secret.getBytes());
    this.key = Keys.hmacShaKeyFor(encodedKey);
  }

  /* 토큰 생성 메서드 */
  public TokenDTO generateToken(Authentication authentication) {
  // 모든 권한 가져와 ","로 이어 문자열로 변환
    String authorities = authentication.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.joining(","));

    log.info("authentication: " + authentication.getName());

    long now = new Date().getTime();

    // access token 생성
    String accessToken = Jwts.builder()
            // 인증에서 가져온 username을 claim sub에 넣어주고
            .setSubject(authentication.getName())
            // auth:권한 형식으로 claim에 추가
            .claim(AUTHORITIES_KEY, authorities)
            // 만료시각은 현재(now)로부터 1일이 지난 때
            .setExpiration(new Date(now + ACCESS_TOKEN_EXPIRE_TIME))
            // key라는 비밀키와 HS256 알고리즘을 사용해 서명
            .signWith(key, SignatureAlgorithm.HS256)
            .compact();

    String refreshToken = Jwts.builder()
            // 만료시각은 현재(now)로부터 2일이 지난 때
            .setExpiration(new Date(now + REFRESH_TOKEN_EXPIRE_TIME))
            // key라는 비밀키와 HS256 알고리즘을 사용해 서명
            .signWith(key, SignatureAlgorithm.HS256)
            .compact();

    log.info("accessToken: " + accessToken.toString());
    log.info("refreshToken: " + refreshToken.toString());

    // accessToken과 refreshToken을 DTO 객체에 담아 반환
    return TokenDTO.builder()
            .accessToken(accessToken)
            .refreshToken(refreshToken)
            .build();
  }

  public Authentication getAuthentication(String accessToken) {
    // accessToken에서 claims 빼내기
    Claims claims = parseClaims(accessToken);

    // 만약 claims에 권한이 null이라면 예외 던지기
    if (claims.get(AUTHORITIES_KEY) == null) throw new CustomException(ErrorCode.INVALID_AUTH_TOKEN);

    // claims에서 sub(이전에 넣었던 username)과 권한 목록 가져와셔 User 객체 생성
    PrincipalDetails principal = new PrincipalDetails(
            User.builder()
                    .username(claims.getSubject())
                    .roles(claims.get(AUTHORITIES_KEY).toString())
                    .build()
    );

    // Authentication 구현체인 UsernamePasswordAuthenticationToken 객체 생성
    return new UsernamePasswordAuthenticationToken(principal, "", principal.getAuthorities());
  }

  /* 유효한 토큰인지 확인 */
  public boolean validateToken(String token) {
    try {
      // key와 주어진 토큰을 검사한다.
      Jwts.parserBuilder()
              .setSigningKey(key)
              .build()
              .parseClaimsJws(token);
      log.info("유효한 토큰입니다.");
      // 유효한 토큰이라면 true 반환
      return true;
    } catch (SecurityException | MalformedJwtException e) {
      log.info("유효하지 않은 토큰입니다.");
    } catch (ExpiredJwtException e) {
      log.info("만료된 토큰입니다.");
    } catch (UnsupportedJwtException e) {
      log.info("지원되지 않는 토큰입니다.");
    } catch (IllegalArgumentException e) {
      log.info("잘못된 토큰입니다.");
    }
    return false;
  }

  // accessToken에서 claims 뽑아내기
  private Claims parseClaims(String accessToken) {
    try {
      return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(accessToken).getBody();
    } catch (ExpiredJwtException e) {
      return e.getClaims();
    }
  }
}

JwtAuthenticationFilter

JWT 를 검증하고 인증 정보 설정하는 역할의 필터
한번의 요청에 대해 한번만 실행되어야 하므로 OncePerRequestFilter 를 상속받아 구현

@RequiredArgsConstructor
@Slf4j
public class JwtAuthenticationFilter extends OncePerRequestFilter {

  private final JwtTokenProvider jwtTokenProvider;

  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

    // 토큰 중 우리가 만들었던 JWT 부분만 가져온다.
    String token = resolveToken(request);

    // token 내용이 있으며 유효한 토큰이라면
    if (token != null && jwtTokenProvider.validateToken(token)) {
      // token을 기반으로 사용자 정보 객체(UsernamePasswordAuthenticationToken) 생성
      Authentication authentication = jwtTokenProvider.getAuthentication(token);
      // 그리고 인증된 정보는 context에 저장
      SecurityContextHolder.getContext().setAuthentication(authentication);

      log.info("set Authentication to security context for '{}', uri: {}", authentication.getName(), request.getRequestURI());
    }
    // 다음 단계 진행
    filterChain.doFilter(request, response);
  }

  /* 토큰 유효한지 확인 + 문자열 처리 */
  private String resolveToken(HttpServletRequest request) {
    // accessToken 가져와서
    String bearerToken = request.getHeader("Authorization");
    // bearerToken이 공백을 제외하고 하나 이상의 문자를 갖고있으며 Bearer 로 시작한다면
    if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
      /* 앞 "Bearer " 뗸 토큰 내용을 반환 */
      return bearerToken.substring(7);
    }
    /* 예상과 다른 토큰이면 null 반환 */
    return null;
  }

  @Override
  public void destroy() {
    super.destroy();
  }
}

JWT Error handler

JwtAccessDeniedHandler

필요한 권한이 존재하지 않는 경우에 403 FORBIDDEN 에러 리턴

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {

  @Override
  public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
    response.sendError(HttpServletResponse.SC_FORBIDDEN);
  }
}

JwtAuthenticationEntryPoint

유요한 자격 증명을 제공하지 않고 접근하려할 때 401 Unauthorized 에러 리턴

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

  @Override
  public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
  }
}

[TIL] 20231227

기넌 — Wed, 27 Dec 2023 01:49:45 +0900

배운 내용 및 정리할 거리

JWT Token 발급 및 spring security 조금 .. 적용
spring security 관련 filter 내용
csrf ?

[Exception Handler] Java, SpringBoot 에서의 예외 처리

기넌 — Sat, 23 Dec 2023 04:22:49 +0900

Exception? Error?

이전 글에서 Java에서 Exception을 checked exception, unchecked exception으로 나눌 수 있다고 했다.
이번 글은 둘 중 unchecked exception를 핸들링한 코드를 정리한다.

이전 글에서 checked exception은 컴파일 시점에 검증이 들어가기 때문에 명시적으로 예외 처리가 필요하다고 했다.
하지만 checked exception가 실사용 시점에도 나올 수 있기 때문에 RuntimeException을 상속받아 unchecked exception처럼 런타임 시에도 예외를 처리할 수 있도록 한다.

ErrorCode

먼저 나올 수 있는 에러 코드를 HttpStatus와 함께 넘길 메시지를 ENUM 구조를 사용해 명시했다.

@AllArgsConstructor
@Getter
public enum ErrorCode {

  /* code: 404 */
  USER_NOT_FOUND(NOT_FOUND, "유저 정보가 존재하지 않습니다."),
  REVIEW_NOT_FOUND(NOT_FOUND, "해당 리뷰가 존재하지 않습니다."),
  MOVIE_NOT_FOUND(NOT_FOUND, "해당 영화가 존재하지 않습니다.");

  private final HttpStatus httpStatus;
  private final String detail;
}

ExceptionHandler

예외가 발생했을 때, 응답으로 보낼 데이터를 handleCustomException 메서드에서 가공해 반환하도록 설정했다.

@ExceptionHandler는 controller 단에서 발생한 예외를 해당 어노테이션이 달린 메서드에서 처리한다는 의미

@Controller
class Super {

    @ExceptionHandler(FileSystemException.class)
    public ResponseEntity<String> handle(Exception e) {
        ...
    }
}

FileSystemException, Super class와 같이 특정 예외에, 클래스에 대해서 처리할 수도 있다.
그런데 이렇게 되면 모든 클래스에 메서드를 만들게 되고 중복되는 코드도 많아진다.
그래서 스프링에서 제공되는 전역적으로 에러 처리를 도와주는 기술 을 사용했다.

RestControllerAdvice / ControllerAdvice

@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

  @ExceptionHandler(CustomException.class)
  public ResponseEntity<ErrorResponse> handleCustomException(CustomException e) {
    ErrorCode errorCode = e.getErrorCode();
    return ResponseEntity.status(HttpStatus.OK).body(
            ErrorResponse.builder()
                    .name(errorCode.name())
                    .status(errorCode.getHttpStatus().value())
                    .code(errorCode.getHttpStatus().name())
                    .msg(errorCode.getDetail())
                    .build()
    );
  }
}

위와 같이 에러 핸들러에 @RestControllerAdvice 또는 @ControllerAdvice를 명시하고, 그 안에 따로 ErrorCode를 기반으로 에러 응답을 반환하도록 CustomException을 매개변수로 전달했다.

CustomException

@AllArgsConstructor
@Getter
public class CustomException extends RuntimeException {

  private final ErrorCode errorCode;
}

CustomException은 RuntimeException을 상속받고 ErrorCode 객체를 갖고있어, throw new CustomException(USER_NOT_FOUND) 처럼 unchecked exception을 발생시킬 수 있다.

그리고 GlobalExceptionHandler 에서 응답 데이터 포맷은 ErrorResponse 로 에러 이름, 코드, 따로 정한 메시지 등 원하는 데이터만을 뽑아 보낼 수 있도록 한다.

@Getter
@Builder
@RequiredArgsConstructor
public class ErrorResponse {

  private final String name;
  private final int status;
  private final String code;
  private final String msg;
}

참고
https://cheese10yun.github.io/checked-exception/

Checked Exception을 대하는 자세 - Yun Blog | 기술 블로그

cheese10yun.github.io

Exception? Error?

기넌 — Sat, 23 Dec 2023 02:00:35 +0900

오류(Error) 에러(Exception)

둘 다 Object - Throwable 을 상속 받고,
Throwable 객체는 오류나 예외에 대한 메시지, 정보를 담고 있다.

Error

시스템 수준에서 일어나는 프로그램 자체에서 해결하기 어려운 오류

Exception

프로그램 수준에서 일어나고, 개발자나 사용자와 같이 사람에 의해 나타나는 오류

그래서 이런 Exception에 대해서는 애플리케이션 상에서 잡을 수 있다.
이것도 Checked Exception, Unchecked Exception 둘로 나뉘는데

	Checked Exception	Unchecked Exception
예외 처리	필수	선택
검증	컴파일 시점	런타임 시점
예시	IOException - FileNotFoundException ...	RuntimeException - IndexOutOfBoundsException, IllegalArgumentException ...

한번 집고 넘어가고 싶은 것은 트랜잭션에 관한 것
대부분 블로그에서

checked - 트랜잭션 불가능(또는 하지 않아도 됨)
unchecked - 트랜잭션 가능(또는 함)

이라고 설명되어 있는데 이 정보는 비약이라고 한다.

사실 spring의 트랜잭션 부분 문서 상에

기본적으로 RuntimeException(Unchecked), Error는 롤백 옵션이 내제되어있다.
다만, Checked Exception 같은 경우는 기본적으로 롤백이 되지 않는다.

이 부분 때문에 다들 오인하는 것 같다고 .. 출처: 백기선님 영상

결론적으로는 기본값이 저럴 수는 있어도 @Transaction 상 옵션으로 rollbackFor와 같은 롤백에 관한 옵션을 줄 수 있다. 따라서, checked exception도 롤백이 가능하고, unchecked도 필요가 없다면 롤백 하지 않을 수 있다.

참고

https://min103ju.github.io/java/java_exception_rollback/
https://choiblack.tistory.com/39
https://bcp0109.tistory.com/303

흑임자

[ERROR] gradle - java version

환경

에러

해결

Oracle21c 컨테이너 띄워 사용하기 (Mac M1)

docker 설치

Colima 설치

Oracle21c 컨테이너 실행

프로세스와 스레드

Program

Process

할당받는 시스템 자원의 예

프로세스의 독립된 메모리 영역

Thread

프로세스 내의 스레드 영역

Stack 이 독립적으로 할당되는 이유?

그 이외의 영역이 공유되는 이유?

참고

[JPA] M:N 관계 (@ManyToMany)

@ManyToMany

다대다 단방향

다대다 양방향

@ManyToMany 한계

연결 테이블 직접 정의 후 다대일 연결(@OneToMany, @ManyToOne)

참고

Transaction

정의

트랜잭션 성질 (ACID)

연산 및 상태

사용 예제

MySQL

출처

index

정의; DB에서 index란?

사용 목적

왜?

언제?

장단점

장점

단점

구현 알고리즘

Hash table

B tree

B+ tree

결론

출처

[Spring Security] OAuth, JWT .. 적용기 (1)

Spring Security

spring security 흐름도

의존성 추가

User

User Entity

PrincipalDetails

PrincipalDetailsService

Config

WebSecurityConfig

Controller 및 Service

AuthController

AuthService

JWT

JwtTokenProvider

JwtAuthenticationFilter

JWT Error handler

JwtAccessDeniedHandler

JwtAuthenticationEntryPoint

[TIL] 20231227

배운 내용 및 정리할 거리

[Exception Handler] Java, SpringBoot 에서의 예외 처리

ErrorCode

ExceptionHandler

RestControllerAdvice / ControllerAdvice

CustomException

Exception? Error?

오류(Error) 에러(Exception)

Error

Exception

참고

`Stack` 이 독립적으로 할당되는 이유?