지노리 블로그

Java Stream API 에서 peek 메서드 사용

jinori — Wed, 21 Jan 2026 23:45:29 +0900

인텔리제이에서 Stream 사용 중 peek를 사용하라고 추천해줬다.

예를 들면 아래와 같이 map을 사용하면 peek을 추천해주는데

인텔리제이에서 추천해주니 Replace하고 그냥 사용할 수 있지만 주석에 써있기로는 디버깅용으로 사용하라고 한다.

왜 추천한걸까? 디버깅이 필요해 보였나?

peek로 변경하면 아래와 같은 코드로 변경되는데 결과 값은 map을 사용했을 때와 같다.

.peek(u -> u.setName("New Name"))

결과 값이 같은데 왜 peek를 디버깅용에만 사용하라고 하는걸까?

주석 내용을 읽어보면 최종 연산 즉 Collect()나 toList() 가 이루어지지 않으면 peek는 실행되지 않으며

자바가 자체적으로 Stream 최적화를 진행할 때 불필요하다고 판단하면 peek 로직이 무시 될 수 있다고 한다.

마지막으로 병렬 스레드에서 peek가 언제 실행되는지 보장되지 않는다고 한다.

GitHub Action으로 CI/CD

jinori — Thu, 11 Jul 2024 22:52:24 +0900

WorkFlow 생성

GitHub 프로젝트 생성 후 Actions 탭으로 이동해 "New workflow" 버튼을 눌러 WorkFlow를 생성합니다.

배포하고자 하는 프로젝트언어와 같거나 비슷한 workflow를 찾습니다.

없으면 "set up a workflow yourselg"를 클릭해 직접 만들면 됩니다.

배포 파일 생성

파일은 .github/worflows 아래 만들어지게 됩니다.
직접 작성한 YML 파일의 예는 아래와 같습니다.

name: Deploy to Raspberry Pi

on:
  workflow_dispatch:
  push:
    branches:
      - master

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-java@v4
      with:
        distribution: 'temurin' # See 'Supported distributions' for available options
        java-version: '21'

    - name: Build with Gradle
      run: ./gradlew build

    - name: Rename jar file
      run: mv ./build/libs/csv-to-json-0.0.1-SNAPSHOT.jar ./app.jar

        
    - name: SCP Jar to server
      uses: appleboy/scp-action@v0.1.7
      with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.NAME }}
        password: ${{ secrets.PASSWORD }}
        port: ${{ secrets.PORT }}
        source: "app.jar,deploy.sh"
        target: /www/csv-to-json
      
        
    - name: SSH to server and deploy
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.NAME }}
        password: ${{ secrets.PASSWORD }}
        port: ${{ secrets.PORT }}
        script: |
          chmod +x /www/csv-to-json/deploy.sh
          sh /www/csv-to-json/deploy.sh

푸시 브랜치를 master로 해서 master에 커밋 시 자동으로 실행 되도록 했습니다.

Java 21 으로 프로젝트를 만들었기 때문에 같은 버전으로 빌드를 돌려주도록 했습니다.

만들어진 jar파일은 "appleboy/scp-action"을 사용해서 대상 서버로 jar파일과 배포 스크립트를 전송합니다.

이 후 "appleboy/ssh-action"을 사용해 deploy.sh 스크립트를 실행해 배포를 완료합니다.

Secrets Key/Value 등록

위 내용에서 보이는 ${{ secrets.xxx }} 와 같은 키들은 Settings 탭에서 Secrets and variables > Actions 에서 등록 가능합니다.

배포 실행

배포 성공/실패 시 아래와 같이 Actions에서 확인 가능하며

Run workflow > Run workflow로 수동 배포가 가능합니다.

(수동 배포를 하기 위해서는 workflow_dispatch: 옵션을 넣어줘야 합니다.)

람다 캡처링 (Lambda Capturing) 정리

jinori — Mon, 20 May 2024 23:05:19 +0900

람다 캡처링은 자바 람다 표현식이 자신이 정의된 범의 외부에 있는 변수를 사용할 수 있는 기능을 의미한다.

캡처링 : 람다 표현식이 외부 변수를 사용하기 위해 이를 캡처하는 기능
final : 람다 표현식에서 사용되는 로컬 변수와 매개변수는 변경되지 않도록 제한해야 함
일관성, 안정성, 스레드 안전성, 컴파일러 최적화
사용 예 : 콜백 함수, 비동기 처리

왜 final 또는 사실상 final이어야 하는가?

로컬 변수와 메서드 매개변수는 final 또는 사실상 final이어야 람다 표현식 내부에서 사용할 수 있으며 이유는 아래와 같다.

일관성 및 안정성: 람다 표현식은 비동기 코드나 콜백으로 사용되는데 이 때 람다 표현식 내부에서 사용하는 외부 변수가 변경될 수 있다면, 값이 예상치 못하게 변경될 위험이 있기 때문에
스레드 안전성: 여러 스레드가 동시에 실행되는 환경에서는 변수가 변경될 수 있기 때문에 값의 일관성 유지를 위해
컴파일러 최적화: 컴파일러는 해당 변수가 변경되지 않음을 보장할 수 있어야 최적화 하기 쉽다.

람다 캡처링의 사용 예시

버튼 클릭 이벤트에서 람다 캡처링

import javax.swing.JButton;
import javax.swing.JFrame;

public class LambdaCaptureExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Lambda Capture Example");
        JButton button = new JButton("Click Me");

        String message = "Button clicked!";

        button.addActionListener(e -> System.out.println(message));

        frame.add(button);
        frame.setSize(200, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

위 예제에서 message 변수는 람다 표현식 내부에서 사용되고 있다.

이 변수는 변경되지 않으므로 사실상 final이다.

비동기 처리에서 람다 캡처링

import java.util.concurrent.CompletableFuture;

public class AsyncLambdaCapture {
    public static void main(String[] args) {
        String taskName = "Async Task";

        CompletableFuture.runAsync(() -> {
            // 비동기 작업 수행
            System.out.println(taskName + " is running");
        });

        // 메인 스레드에서 다른 작업 수행
        System.out.println("Main thread is running");
    }
}

위 예제에서 taskName 변수는 비동기 작업을 수행하는 람다 표현식 내부에서 사용된다.

이 변수는 변경되지 않으므로 사실상 final 이다.

CentOS 7 to Rocky Linux 8

jinori — Sat, 18 May 2024 13:20:33 +0900

CentOS Linux 7가 2024년 6월 30일 지원 종료(End of Life, EOL)될 예정으로 OS 마이그레이션이나

Rocky 8 OS 설치 후 서비스를 이전하는 방법 둘 중 하나를 진행해야 한다.

https://docs.rockylinux.org/guides/migrate2rocky/

Migrating To Rocky Linux - Documentation

How to migrate to Rocky Linux from CentOS Stream, CentOS, AlmaLinux, RHEL, or Oracle LinuxPrerequisites and assumptionsCentOS Stream, CentOS, AlmaLinux, RHEL, or Oracle Linux running on a hardware server or VPS. Non-Stream CentOS is frozen at version 8.5.

docs.rockylinux.org

위 사이트를 참고해 rockylinux에서 제공하는 스크립트를 사용해 마이그레이션을 진행한다.

스크립트는 rocky-lunux 깃허브 https://github.com/rocky-linux/rocky-tools/tree/main/migrate2rocky 에서 다운로드 받거나

명령어로 다운로드 받을 수 있다.

curl https://raw.githubusercontent.com/rocky-linux/rocky-tools/main/migrate2rocky/migrate2rocky.sh -o migrate2rocky.sh

다운로드 받고 서비스 종료 및 백업 후 아래 순서대로 마이그레이션을 진행한다.

마이그레이션은 CentOS 7 -> CentOS 8 -> Rocky 8 순서로 진행한다.

# CentOS7 업데이트 및 reboot
sudo yum -y update --exclude=java*,nginx*
sudo reboot

# 커널 버전 확인
sudo uname -r

# epel-release 설치
sudo yum install epel-release -y

# 패키지 설치
sudo yum install -y yum-utils rpmconf

# YUM 에서 DNF 로 업그레이드
sudo yum install -y dnf
sudo dnf remove -y yum yum-metadata-parser 
sudo rm -Rf /etc/yum

# DNF repository 용 캐시 구성
sudo dnf -y makecache

# CentOS7 패키지 업그레이드
sudo dnf -y upgrade --exclude=java*,nginx*

# epel-release repository 업그레이드
sudo dnf upgrade -y epel-release

# CentOS7 에서 CentOS8 업그레이드
cd /etc/yum.repos.d
  
sudo mkdir backups
  
sudo mv CentOS-* backups
  
# Create new for CentOS BaseOS repo
sudo tee CentOS-Linux-BaseOS.repo<<EOM
[baseos]
name=CentOS Linux \$releasever - BaseOS
baseurl=http://vault.centos.org/8.5.2111/BaseOS/\$basearch/os/
gpgcheck=1
enabled=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-centosofficial
EOM
  
# Create new for CentOS AppStream repo
sudo tee CentOS-Linux-AppStream.repo<<EOM
[appstream]
name=CentOS Linux \$releasever - AppStream
baseurl=http://vault.centos.org/8.5.2111/AppStream/\$basearch/os/
gpgcheck=1
enabled=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-centosofficial
EOM


# CentOS 커널 제거
sudo rpm -e `rpm -q kernel` --nodeps
sudo rpm -e `rpm -q kernel-devel` --nodeps

# 충돌 패키지 제거
sudo rpm -e --nodeps sysvinit-tools

# CentOS8 업그레이드
# 업그레이드 시 충돌하는 패키지 오류가 있을 수 있다. 오류나는 패키지는 삭제 후 진행한다.
sudo dnf remove -y dracut-network redhat-rpm-config openssl11-libs-1:1.1.1k-7.el7.x86_64 python36-rpmconf
 
# dracut-network
# redhat-rpm-config
# openssl11-libs-1:1.1.1k-5.el7.x86_64
# python36-rpmconf
 
sudo dnf -y --releasever=8 --allowerasing --setopt=deltarpm=false distro-sync --exclude=java*,nginx*

# CentOS8 커널 설치
sudo dnf install -y kernel-core

# CentOS8 설치
sudo dnf -y groupupdate "Core" "Minimal Install"

# 시스템 재시작
sudo systemctl reboot

# 재시작 후 버전 확인
cat /etc/redhat-release

정상적인 재시작 확인 후 버전이 CentOS 8 인 것을 확인 후 아래 스크립트를 진행한다.

sudo dnf -y install wget
wget https://raw.githubusercontent.com/rocky-linux/rocky-tools/main/migrate2rocky/migrate2rocky.sh
  
# 스크립트 실행 권한 부여
chmod a+x migrate2rocky.sh
  
# migrate2rocky.sh 내용 중 아래의 내용을 추가한다.
# infomsg $'\nSyncing packages\n\n'
# dnf -y distro-sync --exclude=java*,nginx* || exit_message "Error during distro-sync."
  
sudo ./migrate2rocky.sh -r

# 재시작 
sudo reboot now

# Rocky OS 8 정보 확인
cat /etc/os-release
 
 
NAME="Rocky Linux"
VERSION="8.9 (Green Obsidian)"
ID="rocky"
ID_LIKE="rhel centos fedora"
VERSION_ID="8.9"
PLATFORM_ID="platform:el8"
PRETTY_NAME="Rocky Linux 8.9 (Green Obsidian)"
ANSI_COLOR="0;32"
LOGO="fedora-logo-icon"
CPE_NAME="cpe:/o:rocky:rocky:8:GA"
HOME_URL="https://rockylinux.org/"
BUG_REPORT_URL="https://bugs.rockylinux.org/"
SUPPORT_END="2029-05-31"
ROCKY_SUPPORT_PRODUCT="Rocky-Linux-8"
ROCKY_SUPPORT_PRODUCT_VERSION="8.9"
REDHAT_SUPPORT_PRODUCT="Rocky Linux"
REDHAT_SUPPORT_PRODUCT_VERSION="8.9"

StringJoiner, StringBuilder 정리

jinori — Sat, 18 May 2024 13:11:07 +0900

실무에서 관습적으로 StringBuilder를 사용해 구분자를 처리하는 로직을 보고 StringJoiner로 리팩터링을 진행하며 관련 내용을 정리한다.

StringBuilder

StringBuilder는 문자열을 연결할 때 사용하며

구분자를 추가 할 때 아래와 같이 사용한다.

StringBuilder builder = new StringBuilder();
builder.append("Hello");
builder.append(",");
builder.append("World");
String result = builder.toString(); // "Hello,World"

StringJoiner

StringJoiner는 내부에서 StringBuilder를 사용해 문자열과 문자열을 구분자로 연결하는 작업을 하며

구분자를 추가 할 때 아래와 같이 사용한다.

StringJoiner joiner = new StringJoiner(",");
joiner.add("Hello");
joiner.add("World");
String result = joiner.toString(); // "Hello,World"

벤치마크

StringJoiner는 불필요한 구분자 추가 코드가 필요 없어 코드가 깔끔해진다. 하지만 구분자를 추가하는 후처리 작업을 해주기 때문에 성능은 떨어진다.

StringBuilder의 경우 구분자를 모두 append()로 추가해줘야 하기 때문에 코드가 불필요하게 길어 질 수 있지만 후처리 작업 없이 문자열 그대로를 사용하므로 성능이 좋다.

아래는 StringBuilder와 StringJoiner의 처리 속도 비교를 위한 밴치마크 코드이다.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

import java.util.StringJoiner;
import java.util.function.Supplier;

public class 문자열벤치마크테스트 {

    @Test
    public void stringBuilder벤치마크테스트() {
        int 반복횟수 = 100000;
        int 실행횟수 = 10;

        long stringBuilder평균시간 = 벤치마크(실행횟수, () -> {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 반복횟수; i++) {
                sb.append("테스트").append(i);
            }
            return sb;
        });

        System.out.println("StringBuilder 평균 시간: " + stringBuilder평균시간 + " ns");
        assertTrue(stringBuilder평균시간 > 0); // 시간 측정이 제대로 되었는지 확인
    }

    @Test
    public void stringJoiner벤치마크테스트() {
        int 반복횟수 = 100000;
        int 실행횟수 = 10;

        long stringJoiner평균시간 = 벤치마크(실행횟수, () -> {
            StringJoiner sj = new StringJoiner(", ");
            for (int i = 0; i < 반복횟수; i++) {
                sj.add("테스트" + i);
            }
            return sj;
        });

        System.out.println("StringJoiner 평균 시간: " + stringJoiner평균시간 + " ns");
        assertTrue(stringJoiner평균시간 > 0); // 시간 측정이 제대로 되었는지 확인
    }

    private long 벤치마크(int 실행횟수, Supplier<?> 작업) {
        long 총시간 = 0;

        for (int j = 0; j < 실행횟수; j++) {
            long 시작시간 = System.nanoTime();
            작업.get();
            long 종료시간 = System.nanoTime();
            총시간 += (종료시간 - 시작시간);
        }

        return 총시간 / 실행횟수;
    }
}

StringBuilder 평균 시간: 4508579 ns (약 4.5초)
StringJoiner 평균 시간: 6739203 ns (약 6.7초)

StringBuilder가 StringJoiner보다 평균 약 1.49배(6,739,203 나노초를 4,508,579 나노초로 나눈 값) 더 빠른 것을 알 수 있다.

Nginx Reverse Proxy 정리

jinori — Sat, 18 May 2024 13:09:10 +0900

리버스 프록시란?

리버스 프록시는 클라이언트로부터의 요청을 받아 이를 적절한 백엔드 서버에 전달하고 백엔드 서버의 응답을 다시 클라이언트로 전달하는 역할을 한다.
이 글에서는 Nginx 리버스 프록시에 대한 주요 기능과 기본 설정만 정리한다.

자세한 내용은 공식 문서 참고 https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/

NGINX Reverse Proxy | NGINX Documentation

NGINX Reverse Proxy Configure NGINX as a reverse proxy for HTTP and other protocols, with support for modifying request headers and fine-tuned buffering of responses. This article describes the basic configuration of a proxy server. You will learn how to p

docs.nginx.com

Nginx 리버스 프록시 주요 기능

로드 밸런싱(Load Balancong)
- Nginx는 여러 백엔드 서버로 트래픽을 분산시켜 서버 간 부하를 균등하게 분산시킬 수 있다.
- 라운드 로빈, 가중치 기반 분산, IP 해시 등 다양한 기법을 지원한다.
SSL/TLS 종료(SSL^[각주:1]/TLS^[각주:2] Termination)
- Nginx는 클라이트와의 SSL/TLS 연결을 처리하여 백엔드 서버가 암호화되지 않은 트래픽만 처리하도록 할 수 있다.
  이를 통해 백엔드 서버의 부하를 줄이고 SSL 인증서를 중앙에서 관리할 수 있다.
캐싱
- 정적 콘텐츠나 API 응답 등을 캐싱하여 서버 부하를 줄이고 응답 시간을 단축할 수 있다.
- 특정 조건에 따라 캐시를 제여 할 수 있다.
압축
- Nginx는 클라이언트로 전달하기 전에 응답 데이터를 압축하여 전송 시간을 줄일 수 있다.
보안
- 클라이언트와 백엔드 서버 간의 통신을 분리하려 보안을 강화할 수 있다.
- 방화벽 기능, IP 차단, DDoS 방어 등을 통해 서버를 보호할 수 있다.

Nginx 리버스 프록시 설정 예시

Nginx가 example.com 도메인으로 들어오는 요청을 백엔드 서버(예: http://localhost:8080)로 전달

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

listen: Nginx가 청취할 포트 번호를 지정
location /: 모든 요청을 처리할 위치 블록을 정의
proxy_pass: 요청을 전달할 백엔드 서버의 주소를 지정
proxy_set_header: 백엔드 서버로 전달할 헤더를 설정, 이를 통해 클라이언트의 원래 IP 주소와 프로토콜 정보를 백엔드 서버가 알 수 있게 한다.

SSL이란 보안 소켓 계층(Secure Sockets Layer)으로서 사용자와 서버 간의 데이터를 암호화하는 표준 기술을 말합니다. [본문으로]
전송 계층 보안(TLS)은 기존 SSL 취약성을 수정하는 업그레이드된 SSL 버전입니다. TLS는 더 효율적으로 인증하고 암호화된 통신 채널을 계속 지원합니다. [본문으로]

InputStream, OutputStream 정리

jinori — Sat, 18 May 2024 12:59:52 +0900

스트림(Stream)

스트림이란 데이터를 연속적으로 처리하는 개념이다. 데이터가 한번에 전체가 아닌, 일정한 크기 단위로 전달되거나 처리되는 것을 말하며

실시간 데이터 처리, 자원을 절약하여 효율적인 데이터 처리에 유리하다.

Java에서 사용하는 InputStream, OutputStream은 'java.io' 패키지에 속하며 파일, 네트워크 연결, 메모리 배열 등의 데이터 소스로부터 데이터를 읽거나 쓸 때 사용한다.

InputStream

바이트 단위로 데이터를 읽기 위한 추상 클래스이며 주요 메서드는 아래와 같다.

int read() : 하나의 바이트를 읽고, 해당 바이트를 정수(0-255)로 반환한다. 더 이상 읽을 데이터가 없으면 -1을 반환한다.
int read(byte[] b) : 바이트 배열 'b'에 데이터를 읽어 채운다. 읽은 바이트 수를 반환하며, 더 이상 읽을 데이터가 없으면 -1을 반환한다.
int read(byte[] b, int off, int len) : 바이트 배열 'b'의 'off' 위치부터 최대 'len' 바이트를 읽어 채운다. 읽은 바이트 수를 반환하며, 더 이상 읽을 데이터가 없으면 -1을 반환한다.
void close() : 스트림을 닫고, 사용한 리소스를 해제한다.

아래와 같이 사용한다.

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("example.txt")) {
            int data;
            while ((data = inputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream

바이트 단위로 데이터를 쓰기 위한 추상 클래스이며 주요 메서드는 아래와 같다.

void write(int b) : 하나의 바이트를 쓴다. 입력으로 주어진 정수의 하위 8비트를 사용한다.
void write(byte[] b) : 바이트 배열 'b'의 모든 바이트를 쓴다.
void write(byte[] b, int off, int len) : 바이트 배열 'b'의 'off' 위치부터 'len' 바이트를 쓴다.
void close() : 스트림을 닫고, 사용한 리소스를 해제한다.
void flush() : 버퍼에 저장된 모든 출력 바이트를 강제롤 출력한다.

아래와 같이 사용한다.

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        try (OutputStream outputStream = new FileOutputStream("output.txt")) {
            String data = "Hello, World!";
            outputStream.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

스트림 사용 시 주의점

자원 관리 : InputStream과 OutputStream은 시스템 리소스를 사용하므로 사용 후 반드시 닫아야 한다. 이를 위해 'try-with-resources' 구문을 사용해 자동으로 닫히게 하는 것이 좋다. (Java 7 부터 구문 사용 시 AutoCloseable^[각주:1] 인터페이스를 구현한 객체에 대해 자원을 자동으로 반납한다.)
예외 처리 : 스트림 작업 중에는 예외가 발생할 수 있으므로 적절한 예외 처리가 필요하다.
버퍼링 : 성능을 향샹시키기 위해 버퍼링된 스트림(BufferedInputStream, BufferedOutputStream)을 사용하는 것이 일반적이다.

AutoCloseable은 Java 7에서 도입된 인터페이스로, 리소스를 명시적으로 닫아야 하는 객체를 자동으로 닫을 수 있도록 해줍니다. 이 인터페이스는 java.lang 패키지에 속하며, try-with-resources 문과 함께 사용됩니다. AutoCloseable을 구현하는 클래스는 close() 메서드를 구현해야 합니다. [본문으로]

[Spring] @Scheduled 사용

jinori — Mon, 6 Dec 2021 17:12:45 +0900

특정 기간, 원하는 주기에 따라 작업을 실행하기 위해 @Scheduled 가 사용된다.

@Scheduled 를 사용하기 위해서는 관련 클래스에 @EnableScheduling 을 추가해야한다.

@Scheduled 가 부텨되는 메서드는 파라미터를 가질 수 없고 반드시 void 리턴 타입이어야 하며

아래 세가지 작업을 수행 할 수 있다.

fixedDelay: 이전 작업이 끝난 후 동작
fixedRate: 이전 작업이 끝나는 것과 별개로 일정한 시간 간격으로 실행
cron: 크론 주기에 따라 실행

cron

@EnableScheduling
@Component
public class Scheduler {

    @Scheduled(cron = "1 * * * * *") // 1분 주기
    public void cronJob() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("strDate = " + strDate);

    }

}

@EnableScheduling 사용으로 스프링에게 @Scheduled 사용을 알리고 위와 같이 크론 주기에 따라 코드를 실행 할 수 있다.

// OutPut
strDate = 2021-12-07 14:08:01.002
strDate = 2021-12-07 14:09:01.003

fixedDelay

@EnableScheduling
@Component
public class Scheduler {

    @Scheduled(fixedDelay = 1000) // 작업 후 1초 후 실행
    public void fixedDelayJob() throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("FixedDelayJob = " + strDate);
        System.out.println(Thread.currentThread().getName());
        Thread.sleep(4000);

    }
}

4초 동안 sleep 하기 때문에 5초 후에 다음 작업이 실행된다.

// OutPut
FixedDelayJob = 2021-12-07 14:06:52.925
scheduling-1
FixedDelayJob = 2021-12-07 14:06:57.927
scheduling-1
FixedDelayJob = 2021-12-07 14:07:02.931
scheduling-1

fixedRate

@EnableScheduling
@Component
public class Scheduler {

    @Scheduled(fixedRate = 1000) // 1초 간격 실행
    public void fixedRateJob() throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("FixedDelayJob = " + strDate);
        System.out.println(Thread.currentThread().getName());
        Thread.sleep(2000);

    }

}

2초 동안 sleep 하지만 작업이 시작된 시점부터 1초 간격으로 실행 되기 때문에 2초가 지난 후 바로 실행된다.

// OutPut
FixedDelayJob = 2021-12-07 14:05:42.568
scheduling-1
FixedDelayJob = 2021-12-07 14:05:44.573
scheduling-1
FixedDelayJob = 2021-12-07 14:05:46.575
scheduling-1

실제로 1초 간격으로 실행되기 위해서는 비동기화가 필요하다.

비동기화

이제 fixedRate 코드 메서드에 @Async 를 붙여주면 비동기 작업을 지원해 일정 간격으로 실행된다.

하지만 작업이 길어 쓰레드가 모두 사용중이라면 대기 시간을 가지게 된다.

@Component
@EnableScheduling
@EnableAsync
public class Scheduler {

    @Scheduled(fixedRate = 100) // 1초 간격 실행
    @Async
    public void fixedRateJob() throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("FixedDelayJob = " + strDate);
        System.out.println(Thread.currentThread().getName());
        Thread.sleep(3000);

    }

}

@Async 사용을 위해 @EnableAsync 어노테이션으로 스프링에게 비동기 사용을 알린다.

// OutPut
FixedDelayJob = 2021-12-07 15:42:00.487
task-1
FixedDelayJob = 2021-12-07 15:42:01.481
task-2
FixedDelayJob = 2021-12-07 15:42:02.478
task-3
FixedDelayJob = 2021-12-07 15:42:03.478
task-4
FixedDelayJob = 2021-12-07 15:42:04.478
task-5

여러 스케줄 동시 작업

기본적으로 스케쥴이 사용하는 스레드는 하나이므로 수행해야 할 작업이 여러개라면 스레드 락이 걸릴 수 있다.

따라서 아래와 같이 스레드풀을 사용하도록 설정한다.

@Configuration
public class SchdulerConfig implements SchedulingConfigurer {

    private final int POOL_SIZE = 10;

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(POOL_SIZE); // 대기하는 스레드 개수
        threadPoolTaskScheduler.setThreadNamePrefix("my-scheduled-task-pool-"); // 스레드 이름
        threadPoolTaskScheduler.initialize();
        scheduledTaskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
    }

}

아래와 같이 사용한다.

@Component
@EnableScheduling
public class Scheduler {

    @Scheduled(fixedDelay = 1000) // 작업 후 1초 후 실행
    public void fixedDelayJob() throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("FixedDelayJob = " + strDate);
        System.out.println(Thread.currentThread().getName());
    }

    @Scheduled(fixedRate = 1000) // 1초 간격
    public void fixedRateJob() throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date now = new Date();
        String strDate = sdf.format(now);
        System.out.println("FixedDelayJob = " + strDate);
        System.out.println(Thread.currentThread().getName());
    }

}

// OutPut
FixedDelayJob = 2021-12-07 15:56:42.973
jin-Scheduling2
FixedDelayJob = 2021-12-07 15:56:42.973
jin-Scheduling1
FixedDelayJob = 2021-12-07 15:56:43.973
jin-Scheduling3
FixedDelayJob = 2021-12-07 15:56:43.974
jin-Scheduling4
FixedDelayJob = 2021-12-07 15:56:44.973
jin-Scheduling2
FixedDelayJob = 2021-12-07 15:56:44.974
jin-Scheduling5
FixedDelayJob = 2021-12-07 15:56:45.975
jin-Scheduling6

[Java] Stream 정리

jinori — Sun, 5 Dec 2021 16:48:29 +0900

Stream 특징

Java 8 부터 지원한다.
원본데이터 자체를 변경하지 않는다.
재사용이 불가능하다.
내부 반복을 사용으로 코드가 간결해지고 병렬처리가 쉽다.
람다 표현식을 이용해서 선언형으로 코드를 구현할 수 있다.
스트림 자신을 반환해 스트림 연산 끼리 연결, 파이프 라인을 구성한다. (데이터 소스에 적용하는 데이터베이스 질의와 비슷하다.)

이전 코드와 비교

테스트를 위한 Dish 클래스

public class Dish {

  private final String name;
  private final boolean vegetarian;
  private final int calories;
  private final Type type;

  public Dish(String name, boolean vegetarian, int calories, Type type) {
    this.name = name;
    this.vegetarian = vegetarian;
    this.calories = calories;
    this.type = type;
  }

  public String getName() {
    return name;
  }

  public boolean isVegetarian() {
    return vegetarian;
  }

  public int getCalories() {
    return calories;
  }

  public Type getType() {
    return type;
  }

  public enum Type {
    MEAT,
    FISH,
    OTHER
  }

  @Override
  public String toString() {
    return name;
  }

  public static final List<Dish> menu = Arrays.asList(
      new Dish("pork", false, 800, Type.MEAT),
      new Dish("beef", false, 700, Type.MEAT),
      new Dish("chicken", false, 400, Type.MEAT),
      new Dish("french fries", true, 530, Type.OTHER),
      new Dish("rice", true, 350, Type.OTHER),
      new Dish("season fruit", true, 120, Type.OTHER),
      new Dish("pizza", true, 550, Type.OTHER),
      new Dish("prawns", false, 400, Type.FISH),
      new Dish("salmon", false, 450, Type.FISH)
  );

}

저칼로리의 요리명을 반환하고, 칼로리를 기준으로 요리를 정렬하는 코드를 구현 한다고 할 때

Stream 을 사용하지 않고 코드를 작성

아래와 같이원하는 값을 찾기 위해 전처리하는 과정에서 코드가 길어지게 된다.

public static List<String> getLowCaloricDishesNamesInJava7(List<Dish> dishes) {
    List<Dish> lowCaloricDishes = new ArrayList<>();
    for (Dish d : dishes) {      // 누적자로 요소 필터링
      if (d.getCalories() < 400) {
        lowCaloricDishes.add(d);
      }
    }
    List<String> lowCaloricDishesName = new ArrayList<>();
    Collections.sort(lowCaloricDishes, new Comparator<Dish>() { // 익명 클래스로 요리 정렬
      @Override
      public int compare(Dish d1, Dish d2) {
        return Integer.compare(d1.getCalories(), d2.getCalories());
      }
    });
    for (Dish d : lowCaloricDishes) {
      lowCaloricDishesName.add(d.getName()); // 정렬된 리스트를 처리하며 요리 이름 선택
    }
    return lowCaloricDishesName;
  }

Stream으로 코드 작성

선언형 코드 구현, 내부 반복으로 짧은 코드로 구현 가능하다.

public static List<String> getLowCaloricDishesNamesInJava8(List<Dish> dishes) {
    return dishes.stream()
        .filter(d -> d.getCalories() < 400) // 400 칼로리 이하의 요리 선택
        .sorted(comparing(Dish::getCalories)) // 칼로리로 요리 정렬
        .map(Dish::getName) // 요리명 추출
        .collect(toList()); // 추출된 모든 요리명을 리스트에 저장
  }

두 코드는 모두 아래와 같은 Output 을 가진다.

season fruit
rice

Stream 이란?

Stream 이란 '데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소' 로 정의된다.

연속된 요소 : 컬렉션과 마찬가지로 연속된 값 집합의 인터페이스를 제공, 컬렉션은 자료구조로 시간과 공간에 관련된 요소 저장 및 연산이 주를 이룬다면 스트림은 filter, sorted, map 같은 표현 계산식이 주를 이룬다.
소스 : 리스트로 스트림을 만들면 스트림의 요소는 리스트의 요소의 순서를 유지한다.
데이터 처리 연산 : 스트림은 함수형 프로그래밍, 데이터베이스와 비슷한 연산을 지원 (filter, map, reduce, find, match, sort 등의 사용) 하며 순차적 또는 병렬 연산 수행이 가능하다.

예제로 확인

List<String> names = menu.stream() // 요리 리스트에서 스트림을 얻음
        .filter(dish -> dish.getCalories() > 300) // 파이프라인 연산 - 코칼로리 요리 필터링
        .map(dish -> dish.getName()) // 요리명 추출
        .limit(3) // 선착순 세 개만 선택
        .collect(toList()); // 결과를 다른 리스트로 저장

Output

[pork, beef, chicken]

Stream 연산

stream 생성 -> 중간 연산 -> 최종 연산 순으로 연산이 이루어진다.

중간 연산

filter, sorted 같은 중간 연산은 다른 스트림을 반환해 여러 중간 연산을 연결해 질의를 만들 수 있으며

중간 연산을 모두 합쳐 최종 연산으로 한 번에 처리 된다는 특징이 있다.

연산	반환 형식	연산의 인수	함수 디스크럽터	설명
filter	Stream<T>	Predicate<T>	T -> boolean	해당 스트림에서 주어진 조건(predicate)에 맞는 요소만으로 구성된 새로운 스트림을 반환
map	Stream<R>	Function<T, R>	T -> R	해당 스트림의 요소들을 주어진 함수에 인수로 전달하며, 그 반환 값으로 이루어진 새로운 스트림을 반환
limit	Stream<T>			해당 스트림에서 전달된 개수만큼의 요소만으로 이루어진 새로은 스트림을 반환
sorted	Stream<T>	Comparator<T>	(T, T) -> int	비교자(comparator)를 이용해 정렬하며비교자를 전달하지 않으면 영문사전 순으로 정렬
distinct	Stream<T>			해당 스트림에서 중복된 요소가 제거된 새로운 스트림을 반환

최종 연산

결과를 도출하며 보통 최종 연산에 의해 List, Integer, void 등 스트림 이외의 결과가 반환된다.

연산	반환 형식	설명
forEach	void	스트림의 각 요소를 소비하면서 람다를 적용
count	long(generic)	스트림의 요소 개수를 반환
collect		스트림을 리듀스해 리스트, 맵, 정수 형식의 컬렉션을 만든다.

docker + Nginx Reverse-proxy + Wildcard SSL

jinori — Sun, 20 Jun 2021 00:02:11 +0900

Wildcard SSL이란?

도메인 뿐만이 아니라 서브 도메인 모두 인증지원하는 인증서
예를 들어 도메인이 devgno.me 일 때 이 인증서를 발급, 적용하면
site1.devgno.me, site2.devgno.me ....
모든 서브 도메인도 ssl인증이 적용된다.

도메인 준비

ssl인증서 발급을 위해 도메인을 구한다.

이 글에서는 무료 도메인인 freenom을 사용

인증서 발급

certbot 설치
sudo apt install certbot
Wildcard ssl 발급
sudo certbot certonly --manual --preferred-challenges=dns --email \ jinho021712@gmail.com --server https://acme-v02.api.letsencrypt.org/directory --agree-tos -d devgno.me -d \*.devgno.me
발급 받을 서버에 위 명령어를 입력한다. 이메일과 도메인 입력에 주의
IP주소 수집, 로그로 기록됨을 동의

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator manual, Installer None
Obtaining a new certificate
Performing the following challenges:
dns-01 challenge for hiseon.me

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NOTE: The IP of this machine will be publicly logged as having requested this
certificate. If you're running certbot in manual mode on a machine that is not
your server, please ensure you're okay with that.

Are you OK with your IP being logged?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(Y)es/(N)o: Y

도메인 인증
인증이 된 후 엔터를 치고 넘어가야한다.
도메인 인증을 위해 위 값을 freenom DNS Management에서 아래와 같이 등록
인증 확인
watch dig -t txt \_acme-challenge.devgno.me +short도메인 인증에 시간이 걸릴 수 있으므로 위 명령어로 도메인 인증되었는지 모니터링

docker-compose.yml

version: '3'

services:

  reverse-proxy:
    image: nginx:1.17.10
    container_name: reverse_proxy_demo
    depends_on:
        - ex-page1
        - ex-page2

    volumes:
      - ./reverse_proxy/conf.d:/etc/nginx/conf.d
      - ./reverse_proxy/nginx.conf:/etc/nginx/nginx.conf
      - /etc/letsencrypt:/etc/letsencrypt
      - /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem

    ports:
      - 80:80
      - 443:443

  ex-page1:
    image: ex-page1
    container_name: ex-page1
    build: 
      context: ./ex-page1
    ports:
      - 5001:5001
    restart: on-failure

  ex-page2:
    image: ex-page2
    container_name: ex-page2
    build: 
      context: ./ex-page2
    ports:
      - 5001:5002
    restart: on-failure

기존에 docker-compose를 사용하고 있었다면 port에 443포트만 매핑시켜주고

ssh인증서 폴더 "/etc/letsencrypt"를 volumes에 매핑한다. (개별 파일을 매핑하면 링크파일로 매핑 될 수 있다. 폴더를 매핑시켜주자)

nginx.conf

user nginx;
worker_processes auto;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections 1024;
}

http {

    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    server_names_hash_bucket_size 64;
    server_names_hash_max_size 8192;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;

    server_tokens off; # 응답 헤더에서 서버 버전 숨기기

    keepalive_timeout  65;

    include /etc/nginx/conf.d/*.conf;

}

conf.d 폴더의 conf확장자 파일을 모두 include하도록 한다.

Nginx conf 작성 참고

[

NGINX Docs | Creating NGINX Plus and NGINX Configuration Files

Understand the basic elements in an NGINX or NGINX Plus configuration file, including directives and contexts.

docs.nginx.com

](https://docs.nginx.com/nginx/admin-guide/basic-functionality/managing-configuration-files/)

conf.d > default.conf

conf.d폴더 안에 페이지별 conf 파일을 작성한다.

return을 줘서 http로 연결하면 https로 연결을 유도한다.

https를 사용하기 위해 인증서 위치를 적어준다.

# ex-page1

server {
        listen 80;
        server_name ex-page1.devgno.ga www.ex-page1.devgno.ga;
        charset utf-8;

    # https로 연결
        location / {
        return 307 https://ex-page1.devgno.ga$request_uri;
        }

}

server {
        listen 443;
        listen [::]:443;
        ssl on;
        server_name ex-page1.devgno.ga www.ex-page1.devgno.ga;

        # ssl인증서 위치
        ssl_certificate /etc/letsencrypt/live/devgno.ga/fullchain.pem; 
        ssl_certificate_key /etc/letsencrypt/live/devgno.ga/privkey.pem; 
        ssl_dhparam /etc/ssl/certs/dhparam.pem;

        location / {
                # include proxy_params;
                proxy_pass http://172.17.0.1:5001;
        }

}