thornapp 님의 블로그

하나의 서비스에서 여러 데이터베이스를 동시에 처리해야 하는 경우가 있다.

이때 단일 DataSource 기반의 @Transactional만으로는 여러 데이터베이스 간의 트랜잭션 일관성을 보장하기 어렵다.

예를 들어, 하나의 함수에서 A 데이터베이스 수정 → B 데이터베이스 수정 중 오류 발생

이런 상황에서 A와 B 데이터베이스를 모두 함께 롤백하려면 글로벌 트랜잭션(JTA) 이 필요하다.

JTA가 필요없는 예시:
•회원 정보 수정 → A DB만 사용
•인증 정보 수정 → B DB만 사용

이처럼 상황에 따라 특정 데이터베이스만 접근하는 구조라면, 트랜잭션 매니저를 동적으로 선택하는 방식을 참고하는 것이 더 적절할 수 있다.
(관련 내용은 아래 링크 참고)
https://thornapp.tistory.com/10

아키텍처 구성

• Spring Boot
• Atomikos (JTA Transaction Manager)
• Oracle XA DataSource
• MyBatis
• 다중 DB (Primary / Secondary / Third)

java 코드 예제

@Configuration
public class DataSourceConfig {

    /* =====================================================
     * XA DataSource 설정
     *
     * - AtomikosDataSourceBean은 XA 트랜잭션을 지원하는 DataSource
     * - 각 DataSource는 서로 다른 DB를 바라보지만
     * - JTA TransactionManager에 의해 하나의 글로벌 트랜잭션으로 묶인다
     * ===================================================== */

    /**
     * Primary XA DataSource
     * - 기본으로 사용될 DataSource
     * - @Primary로 지정하여 주입 시 우선 선택
     */
    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return new AtomikosDataSourceBean();
    }

    /**
     * Secondary XA DataSource
     */
    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return new AtomikosDataSourceBean();
    }

    /**
     * Third XA DataSource
     */
    @Bean(name = "thirdDataSource")
    @ConfigurationProperties("spring.datasource.third")
    public DataSource thirdDataSource() {
        return new AtomikosDataSourceBean();
    }

    /* =====================================================
     * JTA Transaction Manager 설정
     *
     * - 여러 XA DataSource를 하나의 글로벌 트랜잭션으로 관리
     * - @Transactional 하나로 다중 DB 트랜잭션을 제어 가능
     * - 내부적으로 2-Phase Commit(2PC) 수행
     * ===================================================== */

    @Bean
    public PlatformTransactionManager transactionManager() throws SystemException {

        // UserTransaction: 트랜잭션의 시작 / 커밋 / 롤백을 제어
        UserTransactionImp userTx = new UserTransactionImp();
        userTx.setTransactionTimeout(30);

        // Atomikos의 핵심 트랜잭션 매니저
        // 여러 XA Resource(DataSource)를 관리
        UserTransactionManager atomikosTxManager = new UserTransactionManager();
        atomikosTxManager.init();

        // Spring에서 사용하는 JTA 트랜잭션 매니저
        // @Transactional 이 이 매니저를 통해 글로벌 트랜잭션을 제어
        return new JtaTransactionManager(userTx, atomikosTxManager);
    }

    /* =====================================================
     * SqlSessionFactory 설정
     *
     * - 각 DataSource마다 별도의 SqlSessionFactory 생성
     * - 하지만 트랜잭션은 모두 JTA(TransactionManager) 하나로 관리됨
     * ===================================================== */

    @Primary
    @Bean(name = "primarySqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(
            @Qualifier("primaryDataSource") DataSource dataSource,
            ApplicationContext context) throws Exception {

        return createSqlSessionFactory(dataSource, context);
    }

    @Bean(name = "secondarySqlSessionFactory")
    public SqlSessionFactory secondarySqlSessionFactory(
            @Qualifier("secondaryDataSource") DataSource dataSource,
            ApplicationContext context) throws Exception {

        return createSqlSessionFactory(dataSource, context);
    }

    @Bean(name = "thirdSqlSessionFactory")
    public SqlSessionFactory thirdSqlSessionFactory(
            @Qualifier("thirdDataSource") DataSource dataSource,
            ApplicationContext context) throws Exception {

        return createSqlSessionFactory(dataSource, context);
    }

    /**
     * SqlSessionFactory 공통 생성 메서드
     *
     * - DataSource만 다르고 MyBatis 설정은 동일
     * - 유지보수를 위해 공통 메서드로 분리
     */
    private SqlSessionFactory createSqlSessionFactory(
            DataSource dataSource,
            ApplicationContext context) throws Exception {

        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setConfigLocation(
                context.getResource("classpath:mybatis/mybatis-config.xml"));
        factoryBean.setMapperLocations(
                context.getResources("classpath:mapper/**/*.xml"));
        return factoryBean.getObject();
    }

    /* =====================================================
     * SqlSessionTemplate 설정
     *
     * - MyBatis에서 실제 SQL 실행에 사용되는 객체
     * - 각각 다른 DB를 바라보지만
     * - 트랜잭션은 JTA에 의해 하나로 묶인다
     * ===================================================== */

    @Primary
    @Bean(name = "primarySqlSessionTemplate")
    public SqlSessionTemplate primarySqlSessionTemplate(
            @Qualifier("primarySqlSessionFactory") SqlSessionFactory factory) {
        return new SqlSessionTemplate(factory);
    }

    @Bean(name = "secondarySqlSessionTemplate")
    public SqlSessionTemplate secondarySqlSessionTemplate(
            @Qualifier("secondarySqlSessionFactory") SqlSessionFactory factory) {
        return new SqlSessionTemplate(factory);
    }

    @Bean(name = "thirdSqlSessionTemplate")
    public SqlSessionTemplate thirdSqlSessionTemplate(
            @Qualifier("thirdSqlSessionFactory") SqlSessionFactory factory) {
        return new SqlSessionTemplate(factory);
    }
}

DB 설정 yml 예제

spring:
  datasource:
    primary:
      unique-resource-name: primary-db
      xa-datasource-class-name: oracle.jdbc.xa.client.OracleXADataSource
      xa-properties:
        URL: jdbc:oracle:thin:@...
        user: primary_user
        password: primary_password
      min-pool-size: 1
      max-pool-size: 50
      borrow-connection-timeout: 30
      maintenance-interval: 60
      max-lifetime: 3600
      max-idleTime: 60

    secondary:
      unique-resource-name: secondary-db
      xa-datasource-class-name: oracle.jdbc.xa.client.OracleXADataSource
      xa-properties:
        URL: jdbc:oracle:thin:@...
        user: secondary_user
        password: secondary_password
      min-pool-size: 1
      max-pool-size: 50
      borrow-connection-timeout: 30
      maintenance-interval: 60
      max-lifetime: 3600
      max-idleTime: 60
      
    third:
      unique-resource-name: third-db
      xa-datasource-class-name: oracle.jdbc.xa.client.OracleXADataSource
      xa-properties:
        URL: jdbc:oracle:thin:@...
        user: third_user
        password: third_password
      min-pool-size: 1
      max-pool-size: 50
      borrow-connection-timeout: 30
      maintenance-interval: 60
      max-lifetime: 3600
      max-idleTime: 60

lifetime 등 설정값은 찾아보시고 본인 프로젝트에 맞게 변경하시기 바랍니다.

적용예시

@Transactional
public void process() {
    primaryMapper.insertA();
    secondaryMapper.insertB();
    thirdMapper.insertC();
    // 하나라도 실패하면 전체 롤백
}

주의사항

• unique-resource-name 중복 금지
• 커스텀한 로컬 트랜잭션과 혼용해서 사용 X
• 성능 오버헤드 고려
• XA 지원 DB만 가능

JTA방식 VS AOP기반 트랜잭션 동적 선택방식

배경 및 문제점

운영 중인 시스템에서 다음과 같은 상황이 있었다.
• 하나의 물리 DB
• 특정 역할에 따른 DB 계정 분리
• MyBatis + Spring Transaction 사용

하지만 Spring의 기본 @Transactional 은
→ 트랜잭션 매니저를 컴파일 타임에 고정해야 한다는 한계가 있다.

따라서 @Transactional 어노테이션 사용 시 롤백이 안되는 상황이 발생함.

해결전략

1. 커스텀 어노테이션 정의
2. AOP에서 요청 정보로 국가 식별
3. 테넌트 코드 기반으로 트랜잭션 매니저 Bean 동적 조회
4. Spring PlatformTransactionManager 직접 제어

전체 구조

@TenantTransactional
        ↓
Aspect (Around)
        ↓
RequestVO 에서 tenantId 추출
        ↓
tenantId → TransactionManager 매핑
        ↓
commit / rollback 직접 제어

예제 코드

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TenantTransactional {

    Class<? extends Throwable>[] rollbackFor() default {};
}

예제 코드2

@Slf4j
@Aspect
@Component
public class TenantTransactionAspect implements ApplicationContextAware {

    private static final String TX_MANAGER_PREFIX = "mybatisTransactionManager_";

    // 테넌트별 트랜잭션 매니저 캐시
    private final ConcurrentMap<String, PlatformTransactionManager> txManagerCache =
            new ConcurrentHashMap<>();

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * 테넌트(Tenant) 기준으로 트랜잭션 매니저를 동적으로 선택하여
     * 트랜잭션을 제어하는 Around Aspect
     */
    @Around("@annotation(tenantTx)")
    public Object applyTenantTransaction(
            ProceedingJoinPoint pjp,
            TenantTransactional tenantTx
    ) throws Throwable {

        /*
         * [1] ProceedingJoinPoint(pjp)
         *
         * - AOP가 가로챈 실제 비즈니스 메서드에 대한 실행 정보
         * - 주요 기능
         *   - pjp.getArgs()  : 메서드 파라미터 조회
         *   - pjp.proceed() : 실제 메서드 실행
         */

        // [2] 메서드 인자 중 RequestVO 추출
        //     → 테넌트 식별자(tenantId)를 얻기 위함
        RequestVO requestVO = extractRequestVO(pjp.getArgs());

        // RequestVO가 없으면 테넌트 판단 불가
        // → 트랜잭션 개입 없이 원본 메서드 그대로 실행
        if (requestVO == null) {
            return pjp.proceed();
        }

        // [3] RequestVO에서 테넌트 ID 추출
        String tenantId = requestVO.getTenantId();

        // [4] 테넌트 ID 기반으로 트랜잭션 매니저 동적 조회
        // ex) mybatisTransactionManager_kr
        PlatformTransactionManager txManager =
                resolveTransactionManager(tenantId);

        // [5] 트랜잭션 정의 생성
        // - PROPAGATION_REQUIRED:
        //   기존 트랜잭션이 있으면 참여, 없으면 신규 생성
        DefaultTransactionDefinition definition =
                new DefaultTransactionDefinition();
        definition.setPropagationBehavior(
                TransactionDefinition.PROPAGATION_REQUIRED
        );

        // [6] 트랜잭션 시작
        TransactionStatus status =
                txManager.getTransaction(definition);

        try {
            // [7] 실제 비즈니스 메서드 실행
            Object result = pjp.proceed();

            // [8] 정상 종료 시 트랜잭션 커밋
            commit(txManager, status);

            return result;

        } catch (Throwable ex) {

            /*
             * [9] 예외 발생 시 롤백 여부 판단
             *
             * - @TenantTransactional.rollbackFor 에 명시된 예외면 롤백
             * - 지정되지 않은 경우 기본 정책 적용
             */
            if (shouldRollback(ex, tenantTx.rollbackFor())) {

                // [10] 롤백 수행
                rollback(txManager, status, ex);

            } else {

                // [11] 롤백 대상이 아닌 예외는 커밋 처리
                commit(txManager, status);
            }

            // [12] 예외는 반드시 다시 던져
            //      상위 레이어에서 처리하도록 함
            throw ex;
        }
    }

    private PlatformTransactionManager resolveTransactionManager(String tenantId) {

        String beanName = TX_MANAGER_PREFIX + tenantId.toLowerCase();

        return txManagerCache.computeIfAbsent(beanName, name -> {
            try {
                return applicationContext.getBean(
                        name,
                        PlatformTransactionManager.class
                );
            } catch (Exception e) {
                log.warn(
                        "Failed to resolve transaction manager. tenantId={}, beanName={}",
                        tenantId,
                        name,
                        e
                );
                throw new IllegalStateException(
                        JavaMessage.getMessage("util_define_server_error"),
                        e
                );
            }
        });
    }

    private void commit(
            PlatformTransactionManager txManager,
            TransactionStatus status
    ) {
        if (!status.isCompleted()) {
            try {
                txManager.commit(status);
            } catch (Exception e) {
                log.warn(
                        "Transaction commit failed. txManager={}",
                        txManager,
                        e
                );
                throw new IllegalStateException(
                        JavaMessage.getMessage("util_define_server_error"),
                        e
                );
            }
        }
    }

    private void rollback(
            PlatformTransactionManager txManager,
            TransactionStatus status,
            Throwable original
    ) {
        if (!status.isCompleted()) {
            try {
                txManager.rollback(status);
            } catch (Exception e) {
                e.addSuppressed(original);
                log.warn(
                        "Transaction rollback failed. txManager={}",
                        txManager,
                        e
                );
                throw new IllegalStateException(
                        JavaMessage.getMessage("util_define_server_error"),
                        e
                );
            }
        }
    }

    private boolean shouldRollback(
            Throwable ex,
            Class<? extends Throwable>[] rollbackFor
    ) {
        if (rollbackFor == null || rollbackFor.length == 0) {
            return ex instanceof Exception;
        }
        for (Class<? extends Throwable> type : rollbackFor) {
            if (type.isAssignableFrom(ex.getClass())) {
                return true;
            }
        }
        return false;
    }

    private RequestVO extractRequestVO(Object[] args) {
        if (args == null) {
            return null;
        }
        for (Object arg : args) {
            if (arg instanceof RequestVO) {
                return (RequestVO) arg;
            }
        }
        return null;
    }
}

사용예시

@TenantTransactional(rollbackFor = { BusinessException.class })
public void processOrder(RequestVO requestVO) {
    // 비즈니스 로직
}

장점과 주의사항

장점
• 테넌트 추가 시 설정만 추가하면 됨
• 서비스 코드 오염 없음
• 하나의 DB에서 유저 분리 구조에 적합

주의사항
• 중첩 트랜잭션 / 다른 @Transactional 과 혼용 금지
• 반드시 Aspect 우선순위 관리
• RequestVO 누락 시 동작 정의 필요

글로벌 서비스를 개발하다 보면, 사용자마다 접속 지역이 달라 시간이 서로 다르게 표시될 수 있습니다.

특히 다국어·다국가 관리자 시스템의 경우, 단순히 브라우저 로컬 시간대로 시간을 보여주는 것은 한계가 있습니다.

예를들어 시스템은 utc 기준이고 java의 Date타입을 그대로 클라이언트로 전송할 경우 클라이언트의 지역 시간대로 자동변환되어 사용자에게 혼란을 줄 수 있습니다.

혼란을 줄수 있는 상황 재현

1. Oracle → Java
•Oracle의 DATE 필드는 Java에서 java.util.Date 또는 LocalDateTime으로 받아 사용
•서버는 기본적으로 UTC 타임존에서 동작하도록 설정

2. Java → JavaScript
•서버는 클라이언트로 시간 정보를 timestamp (long) 형태로 전달 (date.getTime())
•예: 2025-05-29 12:00:00 UTC → 1748510400000

3. JavaScript 클라이언트 처리
const date = new Date(1748510400000);
console.log(date.toString());
•한국(UTC+9): Thu May 29 2025 21:00:00
•인도네시아(UTC+7): Thu May 29 2025 19:00:00

동일한 시간 정보라도, 클라이언트의 시간대 설정에 따라 자동으로 다르게 보입니다.
만약 한국시간으로 설정된 pc를 사용하여 한국사람이 인도네시아 서버를 관리하는 경우 시간이 자동으로 한국시간으로 노출되어 인도네시아에서 접속한 사람과의 혼란이 발생합니다.

문제가 되는 상황

이를 해결하기 위해 DB와 서버는 UTC 기준, 사용자 계정에 설정된 국가의 타임존으로 시간 변환, 클라이언트에서는 변환된 문자열을 그대로 표시하는 구조를 설명합니다.

1. DB는 UTC 기준으로 저장

•모든 DATE, TIMESTAMP는 UTC 기준으로 저장
•SYSTIMESTAMP AT TIME ZONE 'UTC' 등을 활용

2. Java 서버에서 시간대 변환

•각 사용자 계정에 맞는 타임존 정보 사용 (예: "Asia/Seoul", "Asia/Jakarta")
•시간 변환 후 String 형식으로 변환하여 반환

ZonedDateTime utcZoned = instant.atZone(ZoneId.of("UTC"));
ZonedDateTime localTime = utcZoned.withZoneSameInstant(ZoneId.of(userTimeZone));
String formatted = localTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

3. 클라이언트에서는 문자열 그대로 표시

<span>2025-05-29 21:00:00</span>

•프론트에서는 JS Date 객체로 다시 변환하지 않음
•시각적으로 오해 없이 “국가 기준 시간”으로 고정됨

주의할 점

•타임존 변경 시 서버에서 매번 ZonedDateTime 변환이 필요
•사용자별 타임존 설정이 누락되지 않도록 유효성 검증 필요
•서버에서 포맷된 문자열은 반드시 일관된 포맷으로 제공 (yyyy-MM-dd HH:mm:ss 등)


다국가, 다시간대 사용자를 지원하는 시스템에서는 단순한 시간 처리로는 문제를 피할 수 없습니다.
“UTC로 저장 → 사용자 기준 타임존으로 변환 → 문자열 반환” 전략을 적용하였지만 사실 다른 방법도 많습니다.

무엇보다 중요한 것은 ‘시간 처리 방식의 통일성’입니다.
여러 계층(클라이언트, 서버, DB)에서 중복되거나 서로 다른 방식으로 시간을 처리하게 되면, 유지보수가 어려워지고 오류 가능성도 커집니다.
하나의 일관된 기준을 정하고, 그에 따라 시간을 저장하고 변환하는 구조를 갖추는 것이 안정적인 시스템 운영의 핵심입니다.

JWT에 대해 사용해보게 되었는데 JWT에서 시그니처 부분을 암호화하기 위한 방식으로 HMAC 암호화를 사용하였습니다. 그래서 정의 및 예제코드를 작성하여 정리하였습니다.

HMAC이란

HMAC(Hash-based Message Authentication Code)은
메시지의 **무결성(Integrity)**과 **인증(Authentication)**을 보장하기 위한 암호화 방식

•무결성: 메시지가 중간에 변조되지 않았음을 확인
•인증: 메시지가 신뢰할 수 있는 주체로부터 왔음을 확인

동작원리

1. 비밀 키 (Secret Key)
2. 해시 알고리즘 (예: SHA-256)

이 두 가지를 조합하여 고정된 길이의 해시값(MAC)을 생성하여
수신자가 동일한 키로 다시 계산하여 데이터 변조 여부를 검증

검증 시 동일한 키를 사용하여야 되므로 대칭키 방식이며 해시 함수가 충돌을 방지하여 안정성이 확보됨.

코드예제

import javax.annotation.PostConstruct;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import lombok.Synchronized;
import org.apache.commons.codec.binary.Base64;

public class SecurityUtil {

    // 대칭 키: 실제 운영에서는 안전한 난수 값으로 대체해야 합니다.
    private static final String SYMMETRIC_KEY = "symmetericKey";

    private static final String HMAC_SHA256_ALGORITHM = "HmacSHA256";
    private static Mac mac;

    /**
     * 클래스 초기화 시 HMAC 해시 객체를 한 번만 생성하고 초기화합니다.
     */
    @PostConstruct
    public void init() throws Exception {
        mac = Mac.getInstance(HMAC_SHA256_ALGORITHM);
        mac.init(new SecretKeySpec(SYMMETRIC_KEY.getBytes("utf-8"), HMAC_SHA256_ALGORITHM));
    }

    /**
     * 메시지를 HMAC-SHA256 방식으로 해싱하고 Base64로 인코딩합니다.
     * 동기화로 멀티스레드 환경에서도 안전하게 동작합니다.
     */
    @Synchronized
    public static String encodeHMacSha256(final String message) {
        byte[] hash = mac.doFinal(message.getBytes());
        return Base64.encodeBase64String(hash);
    }
}

•@PostConstruct는 Bean 생성 후 호출되어 Mac 객체를 한 번만 초기화
•Mac 객체는 스레드에 안전하지 않기 때문에 @Synchronized로 doFinal() 호출을 보호합니다.
•실제 운영 환경에서는 SYMMETRIC_KEY를 고정된 문자열이 아니라 안전하게 관리되는 키 저장소 또는 환경변수로부터 주입받는 것이 좋음

Syncronized 사용이유

Mac 객체는 내부 상태를 갖고 있어서 doFinal()이 호출되면 상태가 변경된다.
여러 스레드가 동시에 doFinal()을 호출할 경우 충돌이 발생하거나 예외가 발생할 수 있으므로, 반드시 동기화 처리가 필요.

참고사항
https://docs.oracle.com/javase/8/docs/api/javax/crypto/Mac.html

java 8버전 기준으로 doFinal 에 대한 설명을 보면 같은 키에 대해서는 여러번 재사용이 가능하다고 명시되어 있어 재사용 하였고, doFinal 사용 시 내부 상태가 변경되기 때문에 동기화 처리를 추가하였음.

웹 애플리케이션을 개발하다 보면, 프로젝트 내에 있는 이미지 파일을 불러와 <input type="file"> 요소에 직접 넣고, 이를 서버에 전송하고 싶은 상황이 생깁니다.

예를 들어, 기본 이미지가 정해져 있고 사용자가 수정하지 않는 경우, 해당 이미지를 별도의 선택 없이 자동으로 서버에 전달하는 방식으로 활용할 수 있습니다.

전체흐름 요약

1. 프로젝트 내부 이미지 경로를 받아 Base64 데이터로 변환
2. Base64 데이터를 File 객체로 변환
3. File 객체를 input[type=“file”] 요소에 삽입
4. 폼 전송

1. 이미지 경로를 base64 데이터로 변환

imgToBase64: function(file, maxWidth, maxHeight) {
  let src = (typeof file === 'string') ? file : URL.createObjectURL(file);

  return new Promise((resolve, reject) => {
    let image = new Image();

    image.onload = function () {
      let canvas = document.createElement('canvas');
      canvas.width = image.naturalWidth > maxWidth ? maxWidth : image.naturalWidth;
      canvas.height = image.naturalWidth > maxHeight ? maxHeight : image.naturalHeight;

      canvas.getContext('2d').drawImage(image, 0, 0, image.width, image.height);
      let uri = canvas.toDataURL('image/png'); // base64 데이터 생성
      resolve(uri);
    };

    image.src = src;
  });
}

2. Base64 데이터를 File 객체로 변환

dataURLtoFile: function(dataurl, filename) {
  let arr = dataurl.split(','),
      mime = arr[0].match(/:(.*?);/)[1],
      bstr = atob(arr[1]),
      n = bstr.length,
      u8arr = new Uint8Array(n);

  while (n--) {
    u8arr[n] = bstr.charCodeAt(n);
  }

  return new File([u8arr], filename, { type: mime });
}

3. File 객체를 input[type=“file”] 요소에 삽입

function setImage(imgInfo) {
  let fullPath = imgInfo.defaultImg;
  let fileName = fullPath.split('\\').pop().split('/').pop();

  WebUtil.imgToBase64(fullPath, imgInfo.widthSize, imgInfo.heightSize).then(resultData => {
    let file = WebUtil.dataURLtoFile(resultData, fileName);
    let container = new DataTransfer(); // FileList 대체용
    container.items.add(file);
    
    // 파일 input에 주입
    $body.find('#fileSearchFormId')[0].files = container.files;
    $body.find('#fileSearchFormId').eq(0).trigger('change'); // 업로드 트리거
  });
}

위 방법대로 하면 사용자 인터랙션 없이도 html file 입력창에 기본 이미지파일을 등록가능하며 그 입력폼을 전송하여 서버에 파일을 전송가능!