슬개

문자열 불변 객체(Immutable)와 가변 객체(Mutable)의 차이점

슬기로운 개발자 — Wed, 30 Jul 2025 17:38:45 +0900

1. String 불변객체 (Immutable Object)

불변(Immutable): 한 번 생성된 객체의 상태(값)가 변경되지 않는 객체
Java String 클래스가 대표적인 불변객체

특징

String 객체는 한 번 생성되면 내부에 저장된 문자(char 배열)가 바뀌지 않음
문자열을 변경하는 연산(예: concat, replace 등)을 하면 실제로는 새로운 String 객체가 만들어짐
불변성 때문에 여러 스레드에서 안전하게 공유 가능(스레드 안정성)
메모리 관리와 최적화에 유리 (String Pool 활용)

예시

String s1 = "hello";
String s2 = s1.concat(" world");  // 새로운 객체 생성, s1은 변경되지 않음

2. String 가변객체 (Mutable Object)

가변(Mutable): 객체 생성 후 내부 상태를 변경할 수 있는 객체
Java에서는 대표적으로 StringBuilder, StringBuffer가 있음

특징

문자열을 변경할 때 새로운 객체를 생성하지 않고 내부 버퍼를 직접 수정
성능상 이점 (특히 문자열을 자주 수정할 때)
StringBuffer는 동기화(Synchronized) 지원해서 멀티스레드 환경에 안전
StringBuilder는 동기화 안 해서 단일 스레드 환경에서 더 빠름

예시

StringBuilder sb = new StringBuilder("hello");
sb.append(" world");  // 기존 객체 내부가 변경됨

요약 표

구분	불변 객체(Immutable)	가변 객체(Mutable)
대표 클래스	String	StringBuilder, StringBuffer
상태 변경 시	새로운 객체 생성	기존 객체 내부 변경
멀티스레드 안정성	기본적으로 안전	StringBuffer는 안전, StringBuilder는 비안전
성능	변경 많으면 비효율적	문자열 변경 작업에 효율적

String 불변객체와 힙(Heap) 영역 관련 핵심 정리

String 객체는 힙 영역에 저장된다.
실제로 String 객체는 힙(heap) 영역에 생성되고, 내부에는 문자(char 배열)가 저장돼 있어.
불변객체라서 ‘내부 문자 배열’이 바뀌지 않는다.
즉, 생성된 String 객체의 문자 배열은 바뀌지 않고 그대로 유지돼.
참조 변수는 힙에 있는 String 객체의 주소값(참조값)을 가진다.
예를 들어,여기서 s는 스택(stack)에 저장된 참조 변수이고, 실제 문자열 "hello"는 힙 영역에 저장된 String 객체 내부에 있다.

String s = "hello";

새로운 문자열 연산이 일어나면 기존 문자열을 변경하는 게 아니라, 새로운 힙 영역에 다른 String 객체가 만들어지고 참조 변수가 새 객체를 가리킨다.이때는 새로운 String 객체가 힙에 생성되고, s는 새 객체를 참조하게 됨.

s = s + " world";

핵심

불변객체는 기존 힙 영역의 값을 직접 변경하지 않고
참조 변수는 힙 영역에 저장된 객체(문자열 데이터)의 주소를 가리키는 것 뿐임.

스프링 배치 도메인 이해 - Job

슬기로운 개발자 — Mon, 21 Apr 2025 13:37:00 +0900

I. Job 기본 개념

· 배치 계층 구조의 가장 상위에 있는 개념, 하나의 배치 작업을 의미한다.

- "API 서버의 접속 로그 데이터를 통계 서버로 옮기는 배치", Job 자체를 의미

· Job Configuration을 통해 생성되는 객체 단위,

배치 작업을 어떻게 구성하고 실행할 것인지 전체적으로 설정하고 명세해 놓은 객체

· Job을 구성하기 위한 최상위 인터페이스, 스프링 배치의 기본 구현체 제공.

· 여러 Step을 포함하고 있는 컨테이너로서 반드시 한개 이상의 Step으로 구성해야함.

@ 컨테이너란?

애플리케이션을 실행하는 데 필요한 모든 요소(코드, 라이브러리, 설정 파일 등)를 하나로 묶어 경량화된 실행 환경을 제공하는 기술

II. Job 기본 구현체

· SimpleJob(Step을 포함)

- 순차적으로 Step을 실행시키는 Job

- 모든 Job에서 유용하게 사용할 수 있는 표준 기능을 갖고 있음.

· FlowJob(Step을 포함 + Flow 객체 포함)

- 특정한 조건과 흐름에 따라 Step을 구성하여 실행시키는 Job

- Flow 객체를 실행시켜서 작업을 진행함.

III. Job 동작 원리

JobParameters -> JobLauncher -> run(job, parameters)

Job -> execute() -> Steps -> Step

↑

Job 실행메서드 Job void excute(JobExecution)

↑

AbstractJob

name : Job 이름

restartable : 재시작 여부 : 기본값은 true

JobRepository : 메타데이터 저장소

JobExecutionListener : Job 이벤트 리스너

JobParametersIncrementer : JobParameter 증가기

JobParametersValidator : JobParameter 검증기

SimpleStepHandler : Step 실행 핸들러

↑

SimpleJob	FlowJob
steps	Flow

@ Job 구조 디버깅 모드로 따라가보기.

JobConfiguration.java(잡 기본 구성 소스 작성)

package io.springbatch.springbatchseulgae;

import lombok.RequiredArgsConstructor;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@RequiredArgsConstructor
public class JobConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .start(step1())
                .next(step2())
                .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .tasklet(new Tasklet() {
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        System.out.println("step1 was executed");
                        return RepeatStatus.FINISHED;
                    }
                })
                .build();
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .tasklet(new Tasklet() {
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        System.out.println("step2 was executed");
                        return RepeatStatus.FINISHED;
                    }
                })
                .build();
    }

}

작성한 Job 메서드를 기준으로 디버깅 모드해서 따라가면

Job 메서드

Job에 Ctrl + Alt + B 누르면 Choose Implementation of Job을 볼 수 있음.

Job의 구현 메서드

1. JobBuilder 호출

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.batch.core.job.builder;

import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.flow.Flow;

public class JobBuilder extends JobBuilderHelper<JobBuilder> {
    public JobBuilder(String name) {
        super(name);
    }

    public SimpleJobBuilder start(Step step) {
        return (new SimpleJobBuilder(this)).start(step);
    }

    public JobFlowBuilder start(Flow flow) {
        return (new FlowJobBuilder(this)).start(flow);
    }

    public JobFlowBuilder flow(Step step) {
        return (new FlowJobBuilder(this)).start(step);
    }
}

2. 요안의 SimpleJobBuilder 클래스 호출한다.

열어보면 SimpleJob이라는 객체를 생성하고, SimpleJobBuilder 클래스의 start 메서드를 호출하는데 구조를 살펴보면

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.batch.core.job.builder;

import java.util.ArrayList;
import java.util.List;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.SimpleJob;
import org.springframework.batch.core.job.flow.JobExecutionDecider;
import org.springframework.core.task.TaskExecutor;
import org.springframework.util.Assert;

public class SimpleJobBuilder extends JobBuilderHelper<SimpleJobBuilder> {
    private List<Step> steps = new ArrayList();
    private JobFlowBuilder builder;

    public SimpleJobBuilder(JobBuilderHelper<?> parent) {
        super(parent);
    }

    public Job build() {
        if (this.builder != null) {
            return ((FlowJobBuilder)this.builder.end()).build();
        } else {
            SimpleJob job = new SimpleJob(this.getName());
            super.enhance(job);
            job.setSteps(this.steps);

            try {
                job.afterPropertiesSet();
                return job;
            } catch (Exception e) {
                throw new JobBuilderException(e);
            }
        }
    }

    public SimpleJobBuilder start(Step step) {
        if (this.steps.isEmpty()) {
            this.steps.add(step);
        } else {
            this.steps.set(0, step);
        }

        return this;
    }

    public FlowBuilder.TransitionBuilder<FlowJobBuilder> on(String pattern) {
        Assert.state(this.steps.size() > 0, "You have to start a job with a step");

        for(Step step : this.steps) {
            if (this.builder == null) {
                this.builder = new JobFlowBuilder(new FlowJobBuilder(this), step);
            } else {
                this.builder.next(step);
            }
        }

        return this.builder.on(pattern);
    }

    public JobFlowBuilder start(JobExecutionDecider decider) {
        if (this.builder == null) {
            this.builder = new JobFlowBuilder(new FlowJobBuilder(this), decider);
        } else {
            this.builder.start(decider);
        }

        if (!this.steps.isEmpty()) {
            this.steps.remove(0);
        }

        for(Step step : this.steps) {
            this.builder.next(step);
        }

        return this.builder;
    }

    public JobFlowBuilder next(JobExecutionDecider decider) {
        for(Step step : this.steps) {
            if (this.builder == null) {
                this.builder = new JobFlowBuilder(new FlowJobBuilder(this), step);
            } else {
                this.builder.next(step);
            }
        }

        if (this.builder == null) {
            this.builder = new JobFlowBuilder(new FlowJobBuilder(this), decider);
        } else {
            this.builder.next(decider);
        }

        return this.builder;
    }

    public SimpleJobBuilder next(Step step) {
        this.steps.add(step);
        return this;
    }

    public FlowBuilder.SplitBuilder<FlowJobBuilder> split(TaskExecutor executor) {
        for(Step step : this.steps) {
            if (this.builder == null) {
                this.builder = new JobFlowBuilder(new FlowJobBuilder(this), step);
            } else {
                this.builder.next(step);
            }
        }

        if (this.builder == null) {
            this.builder = new JobFlowBuilder(new FlowJobBuilder(this));
        }

        return this.builder.split(executor);
    }
}

3. Step을 저장할 리스트 변수가 선언되어있고

Step을 저장하는 List 변수

4. 따라서 내려가다보면 Job build() 메서드가 보이는데 여기서 SimpleJob 객체를 생성한다.

SimpleJob이라는 객체를 생성한다.

5. 리스트 변수의 선언한 Step을 담아서

SimpleJobBuilder start 메서드

5_1. start 메서드를 호출하고 그에 담겨있는 내용은 다음과 같다.

Step을 담고있는 변수 내용.

6. SimpleJob의 구조는 다음과 같다.

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.batch.core.job;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobInterruptedException;
import org.springframework.batch.core.StartLimitExceededException;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.repository.JobRestartException;
import org.springframework.batch.core.step.StepLocator;

public class SimpleJob extends AbstractJob {
    private List<Step> steps;

    public SimpleJob() {
        this((String)null);
    }

    public SimpleJob(String name) {
        super(name);
        this.steps = new ArrayList();
    }

    public void setSteps(List<Step> steps) {
        this.steps.clear();
        this.steps.addAll(steps);
    }

    public Collection<String> getStepNames() {
        List<String> names = new ArrayList();

        for(Step step : this.steps) {
            names.add(step.getName());
            if (step instanceof StepLocator) {
                names.addAll(((StepLocator)step).getStepNames());
            }
        }

        return names;
    }

    public void addStep(Step step) {
        this.steps.add(step);
    }

    public Step getStep(String stepName) {
        for(Step step : this.steps) {
            if (step.getName().equals(stepName)) {
                return step;
            }

            if (step instanceof StepLocator) {
                Step result = ((StepLocator)step).getStep(stepName);
                if (result != null) {
                    return result;
                }
            }
        }

        return null;
    }

    protected void doExecute(JobExecution execution) throws JobInterruptedException, JobRestartException, StartLimitExceededException {
        StepExecution stepExecution = null;

        for(Step step : this.steps) {
            stepExecution = this.handleStep(step, execution);
            if (stepExecution.getStatus() != BatchStatus.COMPLETED) {
                break;
            }
        }

        if (stepExecution != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Upgrading JobExecution status: " + stepExecution);
            }

            execution.upgradeStatus(stepExecution.getStatus());
            execution.setExitStatus(stepExecution.getExitStatus());
        }

    }
}

IIII. Job 기본 구성 소스 작성.

package io.springbatch.springbatchseulgae;

import lombok.RequiredArgsConstructor;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@RequiredArgsConstructor
public class JobConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .start(step1())
                .next(step2())
                .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .tasklet(new Tasklet() {
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        System.out.println("step1 was executed");
                        return RepeatStatus.FINISHED;
                    }
                })
                .build();
    }

    @Bean
    public Step step2() {
        return stepBuilderFactory.get("step2")
                .tasklet(new Tasklet() {
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        System.out.println("step2 was executed");
                        return RepeatStatus.FINISHED;
                    }
                })
                .build();
    }

}

Spring Batch 시작 - DB 스키마 생성(2)

슬기로운 개발자 — Sun, 20 Apr 2025 18:43:33 +0900

I. DB 스키마 생성, TABLE별 각 역활 정리.

스키마 관계 구성도

@ Job 관련 테이블

BATCH_JOB_INSTANCE

select * from BATCH_JOB_INSTANCE;

- Job이 실행될 때 Jobinstance 정보가 저장됨, jom_name과 job_key를 키로 하여 하나의 데이터가 저장.

- 동일한 job_name과 job_key로 중복 저장될 수 없다.

컬럼정보

BATCH_JOB_EXECUTION
select * from BATCH_JOB_EXECUTION;

- job의 실행정보가 저장되며 Job 생성, 시작/종료 시간, 실행상태, 메세지 등을 관리.

컬럼정보

BATCH_JOB_EXECUTION_PARAMS
select * from BATCH_JOB_EXECUTION_PARAMS;

- Job과 함께 실행되는 JobParameter 정보를 저장

컬럼정보

BATCH_JOB_EXECUTION_CONTEXT
select * from BATCH_JOB_EXECUTION_CONTEXT;

- Job의 실행동안 여러가지 상태정보, 공유 데이터를 직렬화(Json 형식)해서 저장

- Step간 서로 공유 가능함.

컬럼정보

@ Step 관련 테이블

BATCH_STEP_EXECUTION

select * from BATCH_STEP_EXECUTION;

- Step의 실행정보가 저장되어 생성, 시작/종료 시간, 실행상태, 메시지 등을 관리.

컬럼내용

BATCH_STEP_EXECUTION_CONTEXT

select * from BATCH_STEP_EXECUTION_CONTEXT;

- Step의 실행동안 여러가지 상태정보, 공유 데이터를 직렬화(Json 형식)해서 저장

- Step 별로 저장되어 Step 간 서로 공유할 수 없음.

컬럼내용

Spring Batch 시작 - DB 스키마 생성(1)

슬기로운 개발자 — Sun, 20 Apr 2025 15:43:00 +0900

I. 스프링 배치 메타 데이터

· 스프링 배치의 실행 및 관리를 위한 목적으로 여러 도메인들(Job, Step, JobParameters...)의 정보들을 저장 업데이터, 조회할 수 있는 스키마 구성

· 과거.. 현재의 실행에 대한 세세한 정보, 실행에 대한 성공과 실패 여부 등을 관리한다.

- 배치 운용에 있어 리스크 발생시 빠른 대처 가능

· DB 연동할 경우 필수적으로 메타 테이블이 생성되어야 함.

II. 스키마 생성 설정

· 수동 생성 -> 쿼리 복사 후 직접 실행

· 자동 생성 -> spring.batch.jdbc.initialize-schema 설정

· ALWAYS

- 스크립트 항상 실행

- RDBMS 설정이 되어 있을 경우 내장 DB보다 우선적으로 실행

· EMBEDDED

- 내장 DB일 때만 실행되며 스키마가 자동 생성됨, 기본값

· NEVER

- 스크립트 항상 실행안함.

- 내장 DB 일경우 스크립트가 생성이 안되기 때문에 오류 발생.

- 운영에서 수동으로 스크립트 생성 후 설정하는 것을 권장.

application.yml

III. Mysql DB 셋업

1. MySQL 서버, WorkBench 설치

https://code-angie.tistory.com/158

[MySQL] MySQL 설치하기 (윈도우 / windows)

MySQLMySQL은 가장 많이 사용되는 데이터베이스 중 하나이다.무료이기에 간단히 설치해 바로 사용할 수 있다. 윈도우와 리눅스 등 다양한 운영체제에서 사용 가능해 확장성이 뛰어나다. 표준 SQL

code-angie.tistory.com

2. MySQL WorkBench 실행

초기화면

사용자 계정 생성

새로운 사용자(User) 생성

좌측 상단의 메뉴 바에서 Server > Users and Privileges 선택
또는 Navigator 패널에서 Management > Users and Privileges 클릭
상단 탭에서 "Users and Privileges" 창이 열리면, 좌측에서 "Add Account" 클릭
사용자 정보 입력:
- Login Name: 새로 만들 사용자명 (예: dev_user)
- Limit to Hosts Matching: 기본값 % (모든 IP에서 접속 허용)
- Authentication Type: 기본값 그대로 (MySQL Native Authentication)
- Password / Confirm Password: 원하는 비밀번호 입력

왼쪽 하단 Add Account 클릭

권한설정

권한(Privileges) 설정

상단의 Administrative Roles 탭으로 이동
또는 Schema Privileges 탭으로 이동하여 특정 데이터베이스에 대한 권한 설정 가능
빠르게 root처럼 전체 권한을 주고 싶다면:
- Administrative Roles에서 DBA 체크 (모든 권한 포함)
특정 DB만 접근하게 하고 싶다면:
- Schema Privileges > Add Entry 클릭
- 특정 스키마 선택 또는 "All Schema"
- 필요한 권한 선택 (예: SELECT, INSERT, UPDATE 등)

Apply 클릭

3. MySQL Database 추가

CREATE DATABASE springbatch;
show databases;

조회화면

4. MySQL Connections 정보 추가

+클릭

서버 생성 완료.

IIII. DB 스키마 생성

인텔리제이 DB 접속 정보 추가

접속정보 입력

@ 복사할 DML 스크립트 긁어오기.

sql 스크립트 위치

각 DB 별 스키마 생성 스크립트.

@ MySQL DB 기준으로 생성합니다.

-- Autogenerated: do not edit this file

CREATE TABLE BATCH_JOB_INSTANCE  (
    JOB_INSTANCE_ID BIGINT  NOT NULL PRIMARY KEY ,
    VERSION BIGINT ,
    JOB_NAME VARCHAR(100) NOT NULL,
    JOB_KEY VARCHAR(32) NOT NULL,
    constraint JOB_INST_UN unique (JOB_NAME, JOB_KEY)
) ENGINE=InnoDB;

CREATE TABLE BATCH_JOB_EXECUTION  (
    JOB_EXECUTION_ID BIGINT  NOT NULL PRIMARY KEY ,
    VERSION BIGINT  ,
    JOB_INSTANCE_ID BIGINT NOT NULL,
    CREATE_TIME DATETIME(6) NOT NULL,
    START_TIME DATETIME(6) DEFAULT NULL ,
    END_TIME DATETIME(6) DEFAULT NULL ,
    STATUS VARCHAR(10) ,
    EXIT_CODE VARCHAR(2500) ,
    EXIT_MESSAGE VARCHAR(2500) ,
    LAST_UPDATED DATETIME(6),
    JOB_CONFIGURATION_LOCATION VARCHAR(2500) NULL,
    constraint JOB_INST_EXEC_FK foreign key (JOB_INSTANCE_ID)
    references BATCH_JOB_INSTANCE(JOB_INSTANCE_ID)
) ENGINE=InnoDB;

CREATE TABLE BATCH_JOB_EXECUTION_PARAMS  (
    JOB_EXECUTION_ID BIGINT NOT NULL ,
    TYPE_CD VARCHAR(6) NOT NULL ,
    KEY_NAME VARCHAR(100) NOT NULL ,
    STRING_VAL VARCHAR(250) ,
    DATE_VAL DATETIME(6) DEFAULT NULL ,
    LONG_VAL BIGINT ,
    DOUBLE_VAL DOUBLE PRECISION ,
    IDENTIFYING CHAR(1) NOT NULL ,
    constraint JOB_EXEC_PARAMS_FK foreign key (JOB_EXECUTION_ID)
    references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ENGINE=InnoDB;

CREATE TABLE BATCH_STEP_EXECUTION  (
    STEP_EXECUTION_ID BIGINT  NOT NULL PRIMARY KEY ,
    VERSION BIGINT NOT NULL,
    STEP_NAME VARCHAR(100) NOT NULL,
    JOB_EXECUTION_ID BIGINT NOT NULL,
    START_TIME DATETIME(6) NOT NULL ,
    END_TIME DATETIME(6) DEFAULT NULL ,
    STATUS VARCHAR(10) ,
    COMMIT_COUNT BIGINT ,
    READ_COUNT BIGINT ,
    FILTER_COUNT BIGINT ,
    WRITE_COUNT BIGINT ,
    READ_SKIP_COUNT BIGINT ,
    WRITE_SKIP_COUNT BIGINT ,
    PROCESS_SKIP_COUNT BIGINT ,
    ROLLBACK_COUNT BIGINT ,
    EXIT_CODE VARCHAR(2500) ,
    EXIT_MESSAGE VARCHAR(2500) ,
    LAST_UPDATED DATETIME(6),
    constraint JOB_EXEC_STEP_FK foreign key (JOB_EXECUTION_ID)
    references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ENGINE=InnoDB;

CREATE TABLE BATCH_STEP_EXECUTION_CONTEXT  (
    STEP_EXECUTION_ID BIGINT NOT NULL PRIMARY KEY,
    SHORT_CONTEXT VARCHAR(2500) NOT NULL,
    SERIALIZED_CONTEXT TEXT ,
    constraint STEP_EXEC_CTX_FK foreign key (STEP_EXECUTION_ID)
    references BATCH_STEP_EXECUTION(STEP_EXECUTION_ID)
) ENGINE=InnoDB;

CREATE TABLE BATCH_JOB_EXECUTION_CONTEXT  (
    JOB_EXECUTION_ID BIGINT NOT NULL PRIMARY KEY,
    SHORT_CONTEXT VARCHAR(2500) NOT NULL,
    SERIALIZED_CONTEXT TEXT ,
    constraint JOB_EXEC_CTX_FK foreign key (JOB_EXECUTION_ID)
    references BATCH_JOB_EXECUTION(JOB_EXECUTION_ID)
) ENGINE=InnoDB;

CREATE TABLE BATCH_STEP_EXECUTION_SEQ (
    ID BIGINT NOT NULL,
    UNIQUE_KEY CHAR(1) NOT NULL,
    constraint UNIQUE_KEY_UN unique (UNIQUE_KEY)
) ENGINE=InnoDB;

INSERT INTO BATCH_STEP_EXECUTION_SEQ (ID, UNIQUE_KEY) select * from (select 0 as ID, '0' as UNIQUE_KEY) as tmp where not exists(select * from BATCH_STEP_EXECUTION_SEQ);

CREATE TABLE BATCH_JOB_EXECUTION_SEQ (
    ID BIGINT NOT NULL,
    UNIQUE_KEY CHAR(1) NOT NULL,
    constraint UNIQUE_KEY_UN unique (UNIQUE_KEY)
) ENGINE=InnoDB;

INSERT INTO BATCH_JOB_EXECUTION_SEQ (ID, UNIQUE_KEY) select * from (select 0 as ID, '0' as UNIQUE_KEY) as tmp where not exists(select * from BATCH_JOB_EXECUTION_SEQ);

CREATE TABLE BATCH_JOB_SEQ (
    ID BIGINT NOT NULL,
    UNIQUE_KEY CHAR(1) NOT NULL,
    constraint UNIQUE_KEY_UN unique (UNIQUE_KEY)
) ENGINE=InnoDB;

INSERT INTO BATCH_JOB_SEQ (ID, UNIQUE_KEY) select * from (select 0 as ID, '0' as UNIQUE_KEY) as tmp where not exists(select * from BATCH_JOB_SEQ);

@ 실행 ㄱㄱㄱㄱ

붙여넣기.

table 생성 완료.

@ mysql DB를 사용하기 위한 pom.xml 의존성 추가.

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

@application.yml 속성에

# MYSQL 설정
spring:
  config:
    activate:
      on-profile: mysql
  datasource:
    hikari:
      jdbc-url: jdbc:mysql://localhost:3306/springbatch?useUnicode=true@characterEncoding=utf8
      username: seulgae
      password: 12345678
      driver-class-name: com.mysql.cj.jdbc.Driver
  batch:
    jdbc:
      initialize-schema: always

해당 정보 추가.

SpringBatch Hello Spring Batch 시작하기

슬기로운 개발자 — Sun, 20 Apr 2025 14:31:00 +0900

I. 스프링 배치 초기 선언 어노테이션

@SpringBootApplication
@EnableBatchProcessing // 스프링 배치 초기 선언 어노테이션
public class SpringBatchApplication {

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

}

@EnableBatchProcessing
총 4개의 설정 클래스를 실행, 스프링 배치의 모든 초기화 및 실행 구성이 이뤄짐.
스프링 부트 배치의 자동 설정 클래스가 실행됨으로 빈으로 등록된 모든 Job을 검색해서 초기화와 동시에 Job을 수행하도록 구성.

II. 스프링 배치 초기화 설정 클래스

1. SimpleBatchConfiguration
- JobBuilderFactory와 StepBuilderFactory 생성, Job과 Step 생성용
- 스프링 배치의 주요 구성 요소 생성 - 프록시 객체로 생성됨.

Q. 프록시 객체란 : 대리인 역활을 하는 객체, 누군가 대신해서 일을 처리해주는 대리인
A. Proxy(대리인) -> Target(대상)

2. BatchConfigurerConfiguration
a. BasicBatchConfigurer
- SimpleBatchConfiguration에서 생성한 프록시 객체의 실제 대상 객체를 설정하는 설정 클래스
- Bean으로 의존성 주입 받아서 주요 객체들을 참조해서 사용할 수 있음.

b. JpaBatchConfigurer
- JPA 관련 객체를 생성하는 설정 클래스
- 사용자 정의 BatchConfigurer 인터페이스를 사용할 수 있음.

3. BatchAutoConfiguration
- 스프링 배치가 초기화 될 때 자동으로 실행되는 설정 클래스
- Job을 수행하는 JobLauncherApplicationRunner 빈을 생성

III. 스프링 배치 Job 기본 구성

package io.springbatch.springbatchseulgae;

import lombok.RequiredArgsConstructor;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@RequiredArgsConstructor // @Autowired 의존성 주입
@Configuration // 하나의 배치 Job을 정의하고 빈 설정
public class HelloJobConfiguration {

     private final JobBuilderFactory jobBuilderFactory; // Job을 생성하는 빌더 팩토리
     private final StepBuilderFactory stepBuilderFactory; // Step을 생성하는 빌더 팩토리

    @Bean
    public Job helloJob() { // helloJob 이름으로 Job 생성
        return jobBuilderFactory.get("hello Job")
                .start(helloStep1())
                .next(helloStep2())
                .build();
    }

    @Bean
    public Step helloStep1() { // helloStep 이름으로 Step생성
        return stepBuilderFactory.get("helloStep1")
                .tasklet(new Tasklet() { // Step 안에서 단일 태스크로 수행되는 로직 구현
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        // 내용기술
                        System.out.println("Step1 테스트");

                        // Step 안 Tasklet은 무한 반복됨.
                        // 그래서 return 문에
                        // RepeatStatus을 사용해서 종료처리할 수 있음.
                        return RepeatStatus.FINISHED;
                    }
                })
                .build()
                ;
    }

    @Bean
    public Step helloStep2() {
        return stepBuilderFactory.get("helloStep1")
                .tasklet(new Tasklet() {
                    @Override
                    public RepeatStatus execute(StepContribution stepContribution, ChunkContext chunkContext) throws Exception {
                        // 내용기술
                        System.out.println("Step2 테스트");

                        return RepeatStatus.FINISHED;
                    }
                })
                .build()
                ;
    }

    // 최종 동작 : Job 구동 -> Step을 실행 -> Teskelt을 실행

}

Spring Batch 개요

슬기로운 개발자 — Sat, 19 Apr 2025 17:32:46 +0900

I. 배치 핵심 패턴

· Read - 데이터베이스, 파일, 큐에서 다량의 데이터를 조회한다. (추출)

· Process - 특정 방법으로 데이터를 가공한다. (변형)

· Write - 데이터를 수정된 양식으로 다시 저장한다. (적재)

@ DB에서 사용하는 ETL 작업과 비슷

E : Extract(추출)

- 여러 출처(데이터베이스, API, 로그 파일 등)에서 데이터를 끌어오는 단계

ex : MySQL, Oracle, CSV 파일, 외부 시스템 등에서 데이터 수집

T : Transform(변환)

- 데이터를 가공, 정체, 변환하는 단계

ex : 불필요한 컬럼 제거, 날짜 형식 통일, 코드값 변환, 집계 처리 등

L : Load(적재)

- 가공한 데이터를 목적지(DB, 데이터 웨어하우스 등)에 저장

ex : 정제된 데이터를 분석용 데이터베이스에 적재

II. 배치 시나리오

· 배치 프로세스를 주기적으로 커밋

- 최소한의 자원을 가지고 최대한의 성능을 낼 수 있는 커밋 전략, Spring Batch에서 해당 기능을 제공

· 동시 다발적인 Job의 배치 처리, 대용량 병렬 처리

@병렬처리

하나의 스레드가 아닌 멀티 스레드로 데이터를 처리.

· 실패 후 수동 또는 스케줄링에 의한 재시작

· 의존관계가 있는 step 여러 개를 순차적으로 처리

· 조건적 Flow 구성을 통한 체계적이고 유연한 배치 모델 구성

· 반복, 재시도, Skip 처리

III. Spring Batch 아키텍처

@ Application

· 스프링 배치 프레임워크를 통해 개발자가 만든 모든 배치 Job과 커스텀 코드를 포함.

· 개발자는 업무로직의 구현에만 집중하고 공통적인 기반 기술은 프레임웍이 담당하게 한다.

@ Batch Core

· Job을 실행, 모니터링, 관리하는 API로 구성되어 있다.

· JobLauncher, Job, Step, Flow 등이 속한다.

@ Batch Infrastructure

· Application, Core 모두 공통 Infrastructure 위에서 빌드한다.

· Job 실행의 흐름과 처리를 위한 틀을 제공한다.

· Reader, Processor Writer, Skip, Retry 등이 속한다.

클라이언트 요청이란?

슬기로운 개발자 — Wed, 22 Jan 2025 14:40:06 +0900

클라이언트 요청은 브라우저, 모바일 앱,다른 서버 등 다양한 클라이언트가 서버에 HTTP 프로토콜을 사용해 정보를 요청하는 행위입니다. 이 요청은 HTTP 메서드 (GET, POST, PUT, DELETE 등)와 함께 특정 URL을 통해 전달됩니다.

I. 클라이언트 요청의 구성 요소

1. HTTP 메서드

· GET: 데이터 조회를 요청 (예: /products에서 상품 목록 조회).

· POST: 서버에 데이터 전송 및 리소스 생성 요청 (예: /products에서 상품 추가).

· PUT: 기존 데이터를 수정 요청 (예: /products/1에서 상품 정보 업데이트).

· DELETE: 특정 데이터를 삭제 요청 (예: /products/1에서 상품 삭제).

2. URL(Path)

· 클라이언트가 원하는 리소스에 접근하기 위한 경로.

예: /users/123는 사용자 ID가 123인 사용자의 데이터를 요청.

3. HTTP 요청 헤더

· 요청에 대한 부가 정보를 포함. (예: 인증 토큰, 콘텐츠 타입)

Authorization: Bearer <토큰>
Content-Type: application/json

4. HTTP 요청 본문(Body)

· POST 또는 PUT 요청에서 주로 사용되며, 서버에 전송할 데이터를 포함.

{
  "name": "Product A",
  "price": 100
}

5. Spring Controller에서 요청 처리 흐름.

1. 클라이언트 요청이 DispatcherServlet으로 전달.

2. 요청 URL 및 HTTP 메서드에 따라 적절한 컨트롤러 메서드로 매핑.

3. 요청 데이터(경로 변수, 요청 파라미터, HTTP 본문 등)가 컨트롤러 메서드로 전달.

4. 컨트롤러 메서드가 요청을 처리하고 응답을 생성하거나 서비스 계층에 작업을 위임.

Spring MVC 패턴

슬기로운 개발자 — Wed, 22 Jan 2025 13:47:44 +0900

I. Spring MVC란?

· Model-View-Controller 아키텍처 패턴을 기반으로 한 Spring Framework의 웹 애플리케이션 개발 모듈이다.

· 애플리케이션의 각 관심사를 명확히 분리하여 유연하고 유지보수하기 쉬운 코드를 작성가능.

1. 주요 구성 요소

@ Model

· 애플리케이션의 데이터와 비즈니스 로직을 담당.

· 데이터를 처리하거나 DB와 상호작용하는 역할.

· 데이터 객체(VO, DTO)와 이를 처리하는 서비스 계층이 포함될 수 있음.

@ View

· 사용자에게 데이털르 표시하는 역활.

· HTML, JSP, Thymeleaf 등 다양한 템플릿 엔진을 통해 구현 가능.

· 사용자 경험(UX)을 담당하며, 컨트롤러가 전달한 데이터를 표시.

@ Controller

· 사용자의 요청을 처리하고 적절한 응답을 반환하는 역할.

· 비즈니스 로직을 호출하고, 결과 데이터를 모델에 담아 뷰에 전달.

· Spring에서는 @Controller 또는 @RestController 애노테이션으로 정의.

2. Spring MVC 동작 흐름

1. 클라이언트 요청

· 클라이언트가 특정 URL로 요청을 보냄.

2. DispatcherServlet

· 모든 요청은 DispatcherServlet이 가장 먼저 받음.

· 이 서블릿은 프론트 컨트롤러 역할을 하며, 요청을 적절한 컨트롤러로 라우팅.

3. HandlerMapping

· DispatcherServlet은 HandlerMapping을 통해 요청에 매핑되는 컨트롤러를 찾음.

4. Controller 호출

· 매핑된 컨트롤러가 호출되고, 요청을 처리.

· 서비스 계층을 호출해 비즈니스 로직 실행.

· 처리 결과 데이터를 모델 객체에 저장.

5. ViewResolver 호출

· DispatcherServlet은 뷰 이름을 ViewResolver에 전달.

· ViewResolver는 적절한 뷰(JSP, Thymeleaf 등)를 선택하여 클라이언트에게 전달할 응답을 생성.

6. 응답 반환

· 클라이언트가 요청한 결과를 뷰를 통해 렌더링하여 반환.

3. Spring MVC의 장점.

· 유지보수성: 관심사의 분리를 통해 코드 가독성과 유지보수가 쉬움.

· 유연성: 다양한 뷰 기술(JSP, Thymeleaf, JSON 등)과 쉽게 통합.

· 확장성: 의존성 주입과 AOP를 통한 확장 가능.

· REST 지원: RESTful 웹 서비스 개발에 최적화된 기능 제공.

Java 컬렉션 프레임워크인가 아닌가..?

슬기로운 개발자 — Tue, 21 Jan 2025 10:01:27 +0900

2025년 01월 20일 직장 후배가 질문한 내용에 답변을 못했다.

정말 어려운 질문이고 좋은 질문이지만 제대로 답변하지 못하여 공부하고자 만들어 본 포스팅이다.

A. 선배님 자바 컬렉션 인터페이스는 개발자가 직접 호출하고 프레임워크 성격을 띄지 않고 있는거 같은데 왜 프레임워크라고 하는지 모르겠습니다.

자바 컬렉션을 직접 호출하여 사용하는 것만으로는 프레임워크의 특징은 "제어의 역전(Inversion of Control, IoC)"를 명확하게 느낄 수 없기 때문에 질문한 내용.

1. 프레임워크란?

· 특정한 작업을 쉽게 할 수 있도록 설계된, 일련의 규칙과 구조를 제공하는 소프트웨어 시스템

· 일반적인 구조를 제공하고, 세부적인 구현을 개발자가 확장하는 것!!

구분	설명
구조	코드 조직을 위한 체계적인 방식.
표준화	일관된 규칙과 인터페이스 제공.
재사용 가능성	여러 프로젝트에서 활용 가능.
확장성	필요에 따라 커스터마이징 가능.

2. 라이브러리란?

· 라이브러리는 특정 기능을 수행하는 재사용 가능한 코드이 집합.

· 개발자가 필요할 때 호출해서 사용하는 도구로 제어권은 전적으로 개발자에게 있다.

· 라이브러리는 특정 문제를 해결하거나 기능을 쉽게 구현하도록 도와주는 역할

3. 제어의 역전(Inversion of Control, IoC)란?

· 제어의 역전이란, 프로그램의 흐름을 프레임워크가 제어하고, 개발자는 그 흐름에 맞게 특정 작업을 수행하는 방식입니다. 즉, 개발자는 "어디서, 어떻게, 무엇을 호출할지"를 결정하는 것이 아니라, 프레임워크가 그 흐름을 결정하고, 개발자는 특정 작업만 수행하는 방식입니다.

· 예시: Spring Framework

· Spring에서는 의존성 주입(DI)을 통해 객체를 생성하고 관리합니다. 개발자는 객체를 직접 생성하지 않고, 프레임워크(Spring)가 객체를 생성하고 애플리케이션의 흐름을 제어합니다. 이처럼 Spring은 제어의 역전을 따릅니다.

4. 모든 프레임워크에서 제어의 역전이 필수적이지 않다.

자바의 컬렉션 프레임워크와 같은 경우, 개발자가 컬렉션을 명시적으로 호출하고 관리합니다. 즉, 컬렉션 프레임워크는 데이터 관리의 표준화된 방법과 알고리즘을 제공하지만, 프로그램의 흐름을 제어하지는 않기 때문에 제어의 역전이 적용되지 않는다.

5. 프레임워크에서 제어의 역전이 적용되지 않는 경우

· 제어의 역전은 주로 애플리케이션의 구조와 흐름을 제어하는 프레임워크에서 사용됨.

· 하지만 도구나 라이브러리에서는 제어의 역전이 요구되지 않습니다.

· 예를 들어:

자바 컬렉션 프레임워크: 컬렉션을 관리하기 위한 도구로 제공되며, 사용자가 직접 호출하고 제어합니다.
JDBC: 데이터베이스와의 연결을 위한 도구이므로, 사용자가 직접 연결하고 쿼리를 실행하는 방식입니다.

이 경우, 사용자가 제어를 한다고 할 수 있습니다. 즉, 제어의 역전은 요구되지 않습니다.

6. 결론.

일반적으로 프레임워크는 제어의 역전 원칙을 따름. 즉, 개발자는 프레임워크에 의해 호출되고, 그 안에서 특정한 작업을 하게 됩니다. 예를 들어, Spring 프레임워크에서는 애플리케이션의 흐름과 객체 생성 등을 Spring이 관리하고, 개발자는 이를 이용하여 애플리케이션을 개발합니다.

자바 컬렉션에서는 개발자가 직접 컬렉션을 호출하고 사용하는 방식이라 제어의 역전이 명확하지 않습니다. 그럼에도 불구하고, 데이터를 다루는 일련의 작업을 표준화하고, 개발자가 이를 효율적으로 재사용할 수 있게 해주는 점에서 프레임워크로 분류할 수 있습니다.

7. 느낀점.

프레임워크에 대한 개념과 중요특징을 확실하게 알고 있는 후배가 자바 컬레션 프레임워크의 명확하지 않은 특징을 분석하여 이렇게 질문할 수 있다는것에 대단하다고 생각했다.

이마딱

A. 조금 더 쉬운 설명(추가)

프레임워크와 라이브러리를 세상과 물컵에 비유하는 방식으로 설명해볼게요.

물컵(객체): 물컵은 객체 또는 데이터를 담는 그릇으로 비유할 수 있어요. 이는 개발 과정에서 우리가 다루는 핵심 단위(예: 클래스나 객체)라고 볼 수 있죠.
물(기능): 물은 물컵 안에 담는 내용물로, 객체에 담길 데이터나 기능(메서드)을 의미합니다.
라이브러리:
- 라이브러리는 필요한 도구나 재료로 비유할 수 있습니다.
- 예를 들어, 물을 따르는 데 필요한 주전자나 수도꼭지처럼 특정 작업에 필요한 도구라고 생각하면 됩니다.
- 개발자가 직접 라이브러리를 호출해서 필요한 작업(물을 따르는 것)을 수행합니다. 즉, 개발자가 "어디에서" 물을 따를지와 같은 제어권을 가집니다.
프레임워크:
- 프레임워크는 세상 또는 정해진 환경으로 비유할 수 있습니다.
- 이 세상은 물컵에 물을 따르는 과정 전체를 이미 정의하고 있습니다.
- "물을 언제, 어떻게 따를지"는 이미 정해져 있고, 개발자는 물컵만 준비해서 이 세상(프레임워크) 규칙에 맞게 맡기기만 하면 됩니다.
- 제어권이 프레임워크에 있습니다. 이걸 흔히 **제어의 역전(Inversion of Control)**이라고 합니다.

비유로 정리하자면:

라이브러리: 당신이 물컵을 들고 "내가 물을 따를 거야"라고 주도적으로 행동하는 것.
프레임워크: 이미 정해진 환경(세상)이 "네가 물컵만 준비해. 물은 내가 알아서 따를게"라고 관리해주는 시스템.

Java Stream(스트림)

슬기로운 개발자 — Tue, 21 Jan 2025 09:37:31 +0900

I. Java Stream이란?

· Java 8에서 도입된 기능으로, 컬렉션(Collection) 또는 배열과 같은 데이터 소스의 요소를 처리하고 변환하기 위한

선언적이고 함수형 스타일의 API

· 스트림을 사용하면 코드가 간결해지고, 데이터 처리 작업을 병렬화하거나 효율적으로 수행할 수 있음.

1. 선언적 방식

· 스트림 API는 for 또는 while 루프 대신 선언적으로 데이터를 처리한다.

(예: filter, map, collect)

2. 데이터 프름 중심

· 스트림은 데이터의 흐름을 처리하기 위해 사용되며 데이터 자체를 변경하지 않는다.

· 스트림은 원본 데이터를 변경하지 않는 불변성을 보장한다.

3. 중간 연산과 종결연산

· 중간 연산(Intermediate Operation) : 다른 스트림을 반환하며, 연산은 지연(lazy) 평가된다.

· 종결 연산 (Terminal Operation) : 스트림을 처리하고 결과를 반환합니다.
(예: collect, forEach, count)

4. 내부 반복

· 스트림 API는 개발자가 반복(iteration) 처리를 직접 하지 않고, 스트림 내부에서 반복 처리를 수행한다.

5. 병렬 처리

· 스트림 API는 간단한 코드 변경으로 데이터를 병렬로 처리하는 기능을 제공한다.

(예: parallelStream())

6. 장점과 주의해야하는 사항.

@ 장점

· 코드 가독성 증가 (함수형 스타일로 작성)

· 데이터 처리 간결화 (필터링, 변환, 수집 등을 단순화)

· 대용량 데이터 처리에 유리 (병렬 스트림)

@ 주의점
· 스트림은 한 번만 소비 가능(재사용 불가)

· 병렬 스트림 사용 시 공유 자원 처리에 주의

· 중간 연산은 지연 평가되므로 결과를 보려면 종결 연산이 필요

@ 스트림 활용 시 고려할점.

· 병렬 스트림은 데이터의 크기와 연산의 복잡성에 따라 성능이 달라질 수 있으므로 신중히 사용.

· 함수형 인터페이스(Predicate, Function)와 람다 표현식의 조합으로 스트림을 활용하면 더욱 유용.

II. 스트림 API의 기본 구조

1. 스트림 생성

· Stream.of(), Arrays.stream(), 컬렉션의 stream() 메서드를 사용하여 생성.

2. 중간 연산

· 데이터 변환 또는 필터링 작업을 수행.

· filter(): 조건에 맞는 요소만 선택.

· map(): 각 요소를 변환.

· sorted(): 요소를 정렬.

· distinct(): 중복 제거.

3. 종결 연산

· 최종 결괄르 도출.

· collect(): 결과를 컬렉션으로 수집.

· forEach(): 각 요소를 반복 처리.

· reduce(): 모든 요소를 하나의 값으로 합침.

III. 예제 코드

1. 숫자 리스트에서 짝수만 필터링하여 합산.

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        int sumOfEvens = numbers.stream() // 스트림 생성
                .filter(n -> n % 2 == 0)  // 중간 연산: 짝수 필터링
                .mapToInt(n -> n)        // 중간 연산: int로 변환
                .sum();                  // 종결 연산: 합산

        System.out.println("Sum of evens: " + sumOfEvens);
    }
}

2. 문자열 리스트를 대문자로 변환 후 출력.

import java.util.Arrays;
import java.util.List;

public class StreamExample2 {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        names.stream()                  // 스트림 생성
                .map(String::toUpperCase) // 중간 연산: 대문자로 변환
                .forEach(System.out::println); // 종결 연산: 출력
    }
}

3. 병렬 스트림 사용

import java.util.stream.IntStream;

public class ParallelStreamExample {
    public static void main(String[] args) {
        IntStream.range(1, 11)       // 1부터 10까지 범위
                .parallel()          // 병렬 스트림 생성
                .forEach(System.out::println);
    }
}