🌐 Spring Boot에서 로그 출력하는 방법

Spring Boot에서는 로그 출력을 쉽게 설정하고 사용할 수 있습니다. 로그는 애플리케이션의 상태를 파악하고 문제를 디버깅하는 데 매우 중요한 역할을 합니다. 이번 글에서는 Spring Boot에서 로그를 출력하는 방법과 설정 방법에 대해 알아보겠습니다.

📝 Spring Boot 로깅 설정

Spring Boot는 기본적으로 Logback을 로깅 구현체로 사용합니다. Spring Boot에서는 `application.properties` 또는 `application.yml` 파일을 통해 로깅 설정을 할 수 있습니다. 기본적으로 로그 레벨은 INFO로 설정되어 있습니다. 로그 레벨을 변경하거나 로그 파일을 설정할 수 있습니다.

👉 예시: `application.properties`

logging.level.root=INFO  # 기본 로그 레벨 설정
logging.level.org.springframework.web=DEBUG  # 특정 패키지에 대해 로그 레벨 설정
logging.level.org.apache.coyote.http11=TRACE  # org.apache.coyote.http11 패키지의 로그 레벨을 TRACE로 설정

logging.file.name=app.log  # 로그 파일 이름
logging.file.path=/var/logs  # 로그 파일 경로

👉 예시: `application.yml`

logging:
  level:
    root: INFO
    org.springframework.web: DEBUG
    org.apache.coyote.http11: TRACE  # TRACE 로그 레벨 설정
  file:
    name: app.log
    path: /var/logs

위 설정에서는 `org.apache.coyote.http11` 패키지의 로그 레벨을 `TRACE`로 설정했습니다. `TRACE`는 가장 세부적인 레벨로, 로그를 통해 매우 상세한 정보를 출력할 수 있습니다. 이를 통해 HTTP 요청과 관련된 세부적인 정보를 추적할 수 있습니다.

📝 SLF4J 로그 사용하기

Spring Boot에서 로그를 출력하려면 SLF4J API를 사용합니다. SLF4J는 다양한 로깅 구현체와 통합할 수 있는 API입니다. `LoggerFactory`를 통해 로거를 생성하고, `Logger` 객체를 이용하여 로그를 출력할 수 있습니다.

👉 로그 출력 코드

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    
    // SLF4J Logger 선언
    private static final Logger logger = LoggerFactory.getLogger(MyController.class);
    
    @GetMapping("/hello")
    public String hello() {
        logger.debug("디버그 레벨 로그");
        logger.info("정보 레벨 로그");
        logger.warn("경고 레벨 로그");
        logger.error("에러 레벨 로그");
        
        return "Hello, Spring Boot!";
    }
}

📝 로그 레벨

SLF4J를 통해 출력할 수 있는 로그 레벨에는 4가지가 있습니다. 각 로그 레벨은 로그의 중요도를 나타냅니다.

• DEBUG: 개발 중에 유용한 정보를 출력하는 레벨입니다. 디버깅을 할 때 주로 사용됩니다.
• INFO: 애플리케이션의 주요 흐름을 나타내는 로그입니다.
• WARN: 경고 메시지로, 큰 문제는 아니지만 주의해야 할 상황을 알립니다.
• ERROR: 오류가 발생했을 때 출력되는 로그입니다.
• TRACE: 가장 상세한 로그 레벨로, 매우 세부적인 정보 출력에 사용됩니다. 주로 개발 중에 트러블슈팅을 위해 사용됩니다.

📝 Logback 설정 파일 커스터마이징

Spring Boot에서 로그 출력을 더 세밀하게 제어하려면 Logback 설정 파일을 사용하여 로그 출력을 커스터마이징할 수 있습니다. `logback-spring.xml` 파일을 생성하여 콘솔 출력 형식, 로그 파일 경로, 로그 레벨 등을 설정할 수 있습니다.

예시: `logback-spring.xml`

<configuration>
    <!-- 콘솔 로그 출력 설정 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 파일 로그 출력 설정 -->
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>/var/logs/app.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>
    
    <!-- 로그 레벨 설정 -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
</configuration>

📝 외부 로깅 라이브러리 사용

Spring Boot에서는 기본적으로 Logback을 사용하지만, 다른 로깅 라이브러리인 Log4j2를 사용할 수도 있습니다. 이를 위해서는 `spring-boot-starter-log4j2` 의존성을 추가하고, `log4j2-spring.xml` 파일을 통해 설정을 커스터마이징할 수 있습니다.

👉 Log4j2 의존성 추가

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

이 의존성을 추가한 후, `log4j2-spring.xml` 파일을 생성하여 로그 출력을 설정할 수 있습니다.

📝 logging.level.org.apache.coyote.http11=trace

Apache Tomcat의 HTTP/1.1 커넥터를 다루는 내부 클래스입니다.
이 설정을 사용하면 다음과 같은 Tomcat 내부 동작을 로그로 확인할 수 있습니다:

• 클라이언트 요청 파싱 과정
• 커넥션 생성 및 종료
• Keep-Alive 연결 처리
• 헤더 처리 및 파이프라인 관련 정보

🎯결론

Spring Boot에서 로그를 출력하는 방법은 매우 간단하며, SLF4J와 Logback을 사용하면 다양한 로그 레벨과 설정을 통해 애플리케이션의 상태를 쉽게 모니터링하고 문제를 디버깅할 수 있습니다. 로그 출력 형식을 커스터마이징하여 더 세밀하게 로깅을 제어할 수도 있습니다. 올바른 로그 설정은 애플리케이션의 품질을 향상시키고 유지보수성을 높이는 데 중요한 역할을 합니다.

Spring Boot를 이용해 애플리케이션을 개발할 때 가장 중요한 부분 중 하나는 빌드 도구의 선택입니다. Maven과 Gradle은 Spring Boot에서 주로 사용되는 두 가지 빌드 도구로, 각각의 특성과 장단점이 있습니다. 이번 글에서는 두 도구의 특징과 차이점을 자세히 살펴보고, 최근 트렌드에 따른 사용 현황도 분석해 보겠습니다.

1. Maven의 특징

📝 구성 방식

👉 XML 기반 설정:
Maven은 pom.xml 파일을 사용하여 프로젝트 설정, 의존성 관리, 플러그인 설정 등을 선언적으로 구성합니다.

👉 Convention over Configuration:
정해진 기본 구조와 설정 덕분에 초보자도 쉽게 접근할 수 있습니다.

📝 의존성 관리

👉 체계적인 관리:
중앙 저장소를 통해 의존성을 관리하며, 의존성 트리 관리 기능으로 버전 충돌 문제를 최소화합니다.

📝 플러그인 생태계

👉 풍부한 플러그인:
다양한 빌드, 테스트, 배포 작업을 수행할 수 있는 플러그인이 잘 갖춰져 있어 안정적인 빌드 환경을 제공합니다.

📝 학습 곡선

👉 명시적 설정:
XML 기반의 명시적인 설정 방식은 이해하기 쉽지만, 복잡한 구성이 필요할 때는 설정 파일이 길어지고 관리가 어려워질 수 있습니다.

2. Gradle의 특징

📝 구성 방식

👉 DSL 스크립트 방식:
Gradle은 Groovy 또는 Kotlin DSL을 사용해 build.gradle 또는 build.gradle.kts 파일로 빌드 설정을 작성합니다. 코드처럼 작성할 수 있어 매우 유연합니다.

📝 빌드 속도

👉 빠른 빌드:
인크리멘털 빌드, 캐시, 병렬 빌드를 지원하여 대규모 프로젝트에서도 빠른 빌드 시간을 제공합니다.

📝 유연성

👉 커스텀 로직 추가 용이:
스크립트 방식 덕분에 필요에 따라 커스텀 빌드 로직을 쉽게 추가할 수 있으며, 복잡한 빌드 과정도 효율적으로 처리할 수 있습니다.

📝 의존성 관리 및 플러그인

👉 유연한 설정:
Maven과 유사한 의존성 관리 기능을 제공하면서도, 스크립트 기반 설정으로 복잡한 요구사항에 맞게 조정하기가 용이합니다.

3. Maven과 Gradle의 비교

👉 초기 설정 및 유지 관리:
Maven은 표준화된 구조 덕분에 설정과 유지 관리가 용이하지만, Gradle은 복잡한 빌드 로직 구현에 유리한 반면 초기 설정이 다소 복잡할 수 있습니다.

👉 확장성과 성능:
대규모 프로젝트나 빌드 속도가 중요한 상황에서는 Gradle의 인크리멘털 빌드와 캐시 기능이 큰 장점으로 작용합니다.

4. 최근 트렌드와 사용 현황

최근에는 Gradle의 사용이 점점 증가하고 있습니다. 그 이유는 다음과 같습니다.

👉 빠른 빌드 시간:
인크리멘털 빌드와 병렬 빌드 기능 덕분에 대규모 프로젝트에서도 빌드 시간이 크게 단축됩니다.

👉 유연한 스크립팅:
Groovy 또는 Kotlin DSL을 통한 스크립트 방식은 복잡한 빌드 로직을 손쉽게 구현할 수 있어 최신 개발 환경에 적합합니다.

👉 다양한 플랫폼 지원:
Android 개발에서 Gradle이 표준 빌드 도구로 자리 잡으면서, 서버 사이드(Spring Boot)뿐만 아니라 여러 분야에서 Gradle의 인기가 상승하고 있습니다.

반면, Maven은 여전히 많은 기업과 프로젝트에서 사용되며, 안정성과 단순함을 선호하는 팀에서 선택되고 있습니다. 최신 트렌드와 빌드 성능 최적화 요구에 따라 새로운 프로젝트나 대규모 시스템에서는 Gradle의 채택이 늘어나는 추세입니다.

🎯 결론

Spring Boot 프로젝트에서의 빌드 도구 선택은 프로젝트의 규모와 팀의 기술 역량에 따라 달라질 수 있습니다.

👉 Maven
    • 장점: 안정적이고 표준화된 설정, 관리가 쉬움
    • 적합한 경우: 소규모 프로젝트나 초보자, 정해진 규칙을 따르는 환경

👉 Gradle
    • 장점: 빠른 빌드 속도, 유연한 커스텀 빌드 로직 지원
    • 적합한 경우: 대규모 프로젝트, 최신 기술 스택 적용, 복잡한 빌드 로직 필요 시

최근 트렌드를 보면 Gradle의 인기가 상승하고 있으므로, 성능과 유연성이 중요한 프로젝트라면 Gradle을 고려해 보시는 것이 좋습니다. 물론 팀 내 경험이나 프로젝트 특성에 따라 Maven 역시 훌륭한 선택이 될 수 있습니다.

여러분의 프로젝트 환경과 요구사항에 맞는 최적의 빌드 도구를 선택하여 효율적인 개발 환경을 구축해 보시길 바랍니다.

📢 [Java Spring Boot] 스프링 부트에서 Swagger 사용하기

🙌 Swagger는 API 문서를 자동으로 생성해주는 도구로, Spring Boot에서는 Springdoc OpenAPI 라이브러리를 사용하여 쉽게 설정할 수 있습니다.

📝 Swagger(OpenAPI)란?

🙌 Swagger는 REST API를 시각화하여 쉽게 테스트하고 문서를 자동으로 생성해주는 도구입니다.
Spring Boot에서는 주로 springdoc-openapi 라이브러리를 사용하여 Swagger UI를 제공하며, 이를 통해 API를 웹 브라우저에서 손쉽게 확인할 수 있습니다.

📝 Spring Boot에서 Swagger 적용하기

    ✅ springdoc-openapi 의존성 추가

    ✔ Spring Boot 2.x 이상에서는 springdoc-openapi 라이브러리를 사용합니다.
    ✔ Spring Boot 프로젝트에서 다음과 같은 의존성을 추가합니다.

// Gradle - build.gradle
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.5'

// Maven - pom.xml
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.8.5</version> 
</dependency>

    ✅ Swagger UI 확인하기

      🙌 의존성을 추가한 후 프로젝트를 실행하면, Swagger UI를 확인할 수 있습니다.

      ✔ 기본적으로 http://localhost:8080/swagger-ui.html 주소에서 Swagger UI가 제공됩니다.
      ✔ OpenAPI JSON 문서는 http://localhost:8080/v3/api-docs에서 확인할 수 있습니다.


👉 실행 결과 

📝 Swagger 문서화 추가하기

🙌 Swagger에서 API를 보기 좋게 표시하려면, @Operation 및 @Parameter 등의 어노테이션을 활용합니다.

    ✅ Controller에서 API 문서 작성하기

      ✔  @Tag(name, description): API 그룹을 지정합니다.
      ✔  @Operation(summary, description): API의 제목과 설명을 추가합니다.
      ✔  @Parameter(description): 요청 파라미터에 대한 설명을 추가합니다.

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.ArrayList;

@RestController
@RequestMapping("/users")
@Tag(name = "User API", description = "사용자 관리 API")  // API 그룹 태그
public class UserController {

    private final List<String> users = new ArrayList<>();

    @GetMapping
    @Operation(summary = "모든 사용자 조회", description = "저장된 모든 사용자 목록을 조회합니다.")
    public List<String> getUsers() {
        return users;
    }

    @PostMapping
    @Operation(summary = "사용자 추가", description = "새로운 사용자를 추가합니다.")
    public String addUser(@RequestParam @Parameter(description = "추가할 사용자 이름") String name) {
        users.add(name);
        return "User added: " + name;
    }
}

    ✅ DTO(데이터 전송 객체) 문서화

      ✔ Swagger에서 DTO를 자동으로 문서화하려면, @Schema 어노테이션을 사용합니다.

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@Schema(description = "사용자 정보 DTO")
public class UserDto {

    @Schema(description = "사용자 ID", example = "1")
    private Long id;

    @Schema(description = "사용자 이름", example = "홍길동")
    private String name;
}

👉 실행 결과 

📝 Swagger 설정 변경하기

🙌 Swagger의 기본 설정을 변경하려면 application.yml 또는 application.properties에서 설정을 추가합니다.

    ✅ API 기본 정보 설정

// application.yml
springdoc:
  api-docs:
    path: /api-docs  # API 문서 경로 변경
  swagger-ui:
    path: /swagger-ui  # Swagger UI 경로 변경
    operationsSorter: method  # API 정렬 방식 (method 기준)
    disable-swagger-default-url: true  # 기본 Swagger URL 비활성화


// application.properties
springdoc.api-docs.path=/api-docs
springdoc.swagger-ui.path=/swagger-ui
springdoc.swagger-ui.operationsSorter=method
springdoc.swagger-ui.disable-swagger-default-url=true

📝 보안 설정 (Swagger UI 접근 제한)

🙌  Swagger는 개발 및 테스트 환경에서 유용하지만, 운영 환경에서는 보안이 필요합니다.
🙌  Spring Security를 사용하는 경우 Swagger에 대한 접근을 제한할 수 있습니다.

    ✅ Spring Security 설정 추가

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/swagger-ui/**", "/v3/api-docs/**").permitAll()
                .anyRequest().authenticated()
            )
            .csrf(csrf -> csrf.disable());  // CSRF 비활성화 (개발 환경)

        return http.build();
    }
}

📝 Swagger UI에서 API 테스트하기

🙌 이제 Swagger UI에서 API를 테스트할 수 있습니다.

    ✅ Swagger UI 접속

      ✔ 브라우저에서 http://localhost:8080/swagger-ui.html 열기

    ✅ API 테스트

      ✔  GET /users 실행 → 모든 사용자 목록 확인
      ✔  POST /users?name=홍길동 실행 → 사용자 추가
      ✔  다시 GET /users 실행 → 추가된 사용자 확인

📚  Swagger 적용 과정 요약

✅ springdoc-openapi  의존성 추가
✅ @Operation, @Parameter 등을 활용하여 API 문서화
✅ Swagger UI에서 API 테스트 (/swagger-ui)
✅ application.yml에서 Swagger 설정 변경 가능
✅ Spring Security 설정을 추가하여 접근 제한 가능

🚀 Swagger를 활용하면 API를 보다 체계적으로 관리할 수 있으며, 개발자 간의 협업도 용이해집니다. 

📢 [java spring boot] cors 허용하는 방법

📌 REST API를 통해 다른 서버의 데이터에 접근하는 경우 CORS(Cross-Origin Resource Sharing) 정책 위반 문제로 오류가 발생할 수 있습니다. 

📌 크롬의 개발자 도구에서 확인하면 아래와 같은 오류를 확인할 수 있습니다.
Access to XMLHttpRequest at '데이터 제공 도메인' from origin '데이터 요청 도메인' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.

📌 데이터 제공 서버에 설정을 통해 문제를 해결할 수 있습니다.

📝 Controller에서 개별적으로 CORS 설정하기

🙌 특정 컨트롤러 또는 메서드에만 CORS를 허용하고 싶다면, @CrossOrigin 애너테이션을 사용하면 됩니다.

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://example.com", allowedHeaders = "*") // 특정 도메인 허용
public class SampleController {

    @GetMapping("/data")
    public String getData() {
        return "Hello, CORS!";
    }

    @PostMapping("/submit")
    @CrossOrigin(origins = "http://anotherdomain.com") // 특정 메서드에만 허용
    public String submitData(@RequestBody String data) {
        return "Received: " + data;
    }
}

📝 전역 CORS 설정

🙌 Spring Security를 사용하지 않거나, 단순한 CORS 설정이 필요한 경우 WebMvcConfigurer를 이용할 수 있습니다.

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@EnableWebMvc
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**") // 모든 엔드포인트에 대해 CORS 적용
                .allowedOrigins("http://example.com") // 허용할 도메인
                // 여러 Origin을 허용하려면 ,로 구분
                // allowedOrigins("*") → 모든 도메인 허용 (보안상 위험할 수 있음)
                // allowCredentials(true) 사용 시, allowedOrigins("*")를 사용할 수 없음
                .allowedMethods("GET", "POST", "PUT", "DELETE") // 허용할 HTTP 메서드
                .allowedHeaders("*") // 모든 헤더 허용
                .allowCredentials(true); // 쿠키 인증 허용
    }
}

또는, 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {

            @Override
            public void addCorsMappings(org.springframework.web.servlet.config.annotation.CorsRegistry registry) {
                registry.addMapping("/**")
                    .allowedOrigins("http://example.com")
                    .allowedMethods("GET", "POST", "PUT", "DELETE")
                    .allowedHeaders("*");
            }
        };
    }
}

이런 식으로도 가능합니다.

📝 Spring Boot 설정 파일 (application.yml)로 CORS 설정

🙌 Spring Boot 2.4 이상에서는 application.yml에서도 CORS 설정을 할 수 있지만, WebMvcConfigurer나 SecurityConfig보다 세부적인 설정이 어렵습니다.

spring:
  web:
    cors:
      allowed-origins: "http://example.com"
      allowed-methods: "GET,POST,PUT,DELETE"
      allowed-headers: "*"
      allow-credentials: true

📝 Spring Security와 함께 글로벌 CORS 설정하기

🙌 Spring Security를 사용할 경우 WebMvcConfigurer만 설정해도 CORS 문제가 해결되지 않을 수 있습니다. 이럴 때는 SecurityFilterChain에서 CORS 설정을 적용해야 합니다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.config.annotation.web.configurers.CorsConfigurer;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .cors(cors -> cors.configurationSource(request -> {
                var config = new org.springframework.web.cors.CorsConfiguration();
                config.addAllowedOrigin("http://example.com"); // 허용할 도메인
                config.addAllowedMethod("*"); // 모든 HTTP 메서드 허용
                config.addAllowedHeader("*"); // 모든 헤더 허용
                return config;
            }))
            .csrf(csrf -> csrf.disable()) // 필요시 CSRF 비활성화
            .authorizeHttpRequests(auth -> auth.anyRequest().permitAll()) // 모든 요청 허용 (설정에 맞게 수정)
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS));

        return http.build();
    }
}

📢  [spring boot] mybatis - mssql application.yml 설정

✅ Dependencies 추가 

✔ Dependencies에 MyBatis Framework와 MSSql Driver를 추가하면 
build.gradle 에 dependencies에 아래와 같이 추가됩니다.

    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.4'
    runtimeOnly 'com.microsoft.sqlserver:mssql-jdbc'
    testImplementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter-test:3.0.4'

🤔 추가 후 프로젝트를 Run하면 에러가 발생합니다.

✅ application 설정 추가

✔  application.properties, 또는 application.yml에 아래와 같이 설정을 해 주어야 합니다.

# application.yml
# 서버 설정
server:
  port: 8080  # 서버가 실행될 포트를 지정합니다. 여기서는 8080번 포트를 사용합니다.

# Spring 프레임워크 설정
spring:
  datasource:  # 데이터베이스 연결 정보를 설정합니다.
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    url: jdbc:sqlserver://localhost:1433;databaseName=databasename;encrypt=true;trustServerCertificate=true
    username: username  # 데이터베이스 접속에 사용할 사용자 이름입니다.
    password: password  # 데이터베이스 접속에 사용할 비밀번호입니다.

# MyBatis 설정
mybatis:
  mapper-locations: classpath:mapper/**/*.xml  # MyBatis 매퍼 파일(.xml)의 위치를 지정합니다.

🙌 성공적인 실행이 되었기를.... 

📌 MultipartFile이란?

MultipartFile은 Spring Framework에서 제공하는 인터페이스로, HTTP 요청을 통해 업로드된 파일을 다룰 때 사용됩니다. multipart/form-data 타입의 요청을 처리할 수 있도록 설계되어 있으며, 이를 활용하면 이미지, 문서 등 다양한 파일을 서버로 업로드할 수 있습니다.

1️⃣ MultipartFile 기본 개념

Spring에서는 클라이언트가 파일을 업로드할 때 multipart/form-data 형식으로 요청을 보내야 합니다. 이때 Spring의 MultipartResolver가 요청을 해석하고, MultipartFile 객체를 생성하여 컨트롤러에서 이를 받을 수 있도록 합니다.

✅ MultipartFile 인터페이스 주요 메서드

2️⃣ 하나의 파일 업로드 예제 (Spring Boot)

Spring Boot에서 MultipartFile을 이용하여 파일을 업로드하는 예제를 만들어 보겠습니다.

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;

@RestController
@RequestMapping("/upload")
public class FileUploadController {

    @PostMapping
    public String uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return "파일이 비어 있습니다.";
        }

        // 파일 저장 경로 (예제: 로컬 디렉토리)
        String filePath = "C:/upload/" + file.getOriginalFilename();

        try {
            file.transferTo(new File(filePath)); // 파일 저장
            return "파일 업로드 성공: " + file.getOriginalFilename();
        } catch (Exception e) {
            return "파일 업로드 실패: " + e.getMessage();
        }
    }
}

📝 파일 업로드 테스트 (Postman)

위의 컨트롤러를 실행한 후 Postman을 사용하여 파일 업로드를 테스트할 수 있습니다.

1. Postman 실행
2. POST 요청을 보낼 URL: http://localhost:8080/upload
3. Body → form-data 선택
4. key 값을 file로 설정 (컨트롤러에서 @RequestParam("file")로 받으므로)
5. Type을 File로 선택 후 업로드할 파일 추가
6. Send 버튼 클릭 → 응답 확인
   

💡 첨부파일 앞에 느낌표가 있다면 Working Directory를 설정해야 합니다.

🔧 Postman의 작업 디렉토리 설정 변경

1. Postman 실행
2. Settings(설정) → General(일반) 탭으로 이동
3. Working Directory(작업 디렉토리) 항목 찾기
4. "Change Directory"(디렉토리 변경) 버튼 클릭
5. 업로드할 파일이 있는 폴더를 선택하여 작업 디렉토리로 설정
6. 설정 저장 후 Postman 재시작

 👉  이렇게 하면 Postman이 해당 폴더 내 파일을 정상적으로 참조할 수 있습니다. (느낌표시가 사라짐~)

👉  Send 버튼을 누르면 정상적으로 파일이 업로드됩니다.

3️⃣ 여러 개의 파일 업로드

파일을 여러 개 업로드하고 싶다면 List<MultipartFile>을 사용하면 됩니다.

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.List;

@RestController
@RequestMapping("/multiple")
public class MultiFileUploadController {

    @PostMapping
    public String uploadMultipleFiles(@RequestParam("files") List<MultipartFile> files) {
        if (files.isEmpty()) {
            return "파일이 없습니다.";
        }

        String uploadPath = "C:/upload/";
        StringBuilder responseMessage = new StringBuilder();

        for (MultipartFile file : files) {
            try {
                file.transferTo(new File(uploadPath + file.getOriginalFilename()));
                responseMessage.append("파일 업로드 성공: ").append(file.getOriginalFilename()).append("\n");
            } catch (IOException e) {
                responseMessage.append("파일 업로드 실패: ").append(file.getOriginalFilename()).append("\n");
            }
        }
        return responseMessage.toString();
    }
}

✔ @RequestParam("files") List<MultipartFile> files를 사용하여 여러 개의 파일을 받습니다.
✔ 반복문을 사용하여 각 파일을 저장합니다.

🔧 Postman 테스트 방법

1. POST 요청을 보낼 URL: http://localhost:8080/upload/multiple
2. Body → form-data 선택
3. key 값을 files로 설정
4. Type을 File로 선택 후 여러 개의 파일 추가
5. Send 버튼 클릭 → 응답 확인

👉 테스트 결과입니다.

4️⃣ 파일 크기 제한

application.properties파일에서 업로드할 파일 크기를 설정할 수 있습니다.

spring.servlet.multipart.enabled=true
spring.servlet.multipart.max-file-size=5MB      # 개별 파일 크기 제한
spring.servlet.multipart.max-request-size=20MB  # 전체 요청 크기 제한

5️⃣ 업로드 파일 확장자 제한 (예: 이미지만 허용)

파일 확장자를 검사하여 특정 유형의 파일만 업로드하도록 설정할 수도 있습니다.

@RestController
@RequestMapping("/limit")
public class LimitUploadController {

    @PostMapping
    public String limitUpload(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return "파일이 없습니다.";
        }

        // 허용할 확장자 목록
        List<String> allowedExtensions = List.of("jpg", "jpeg", "png", "gif");

        // 파일 확장자 추출
        String originalFilename = file.getOriginalFilename();
        assert originalFilename != null;
        String fileExtension = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);

        if (!allowedExtensions.contains(fileExtension.toLowerCase())) {
            return "허용되지 않은 파일 형식입니다.";
        }

        try {
            file.transferTo(new File("C:/upload/" + originalFilename));
            return "파일 업로드 성공: " + originalFilename;
        } catch (IOException e) {
            return "파일 업로드 실패: " + e.getMessage();
        }
    }
}

-- 끝 --

[spring boot] dependencies (의존성) 설정 

1. 의존성 정의의 기본 형식

의존성을 선언하는 기본 형식은 다음과 같습니다.

dependencies {
    configuration "group:artifact:version"
}

• configuration: 의존성의 역할이나 범위를 정의합니다. (예: implementation, testImplementation, runtimeOnly 등)
• group: 라이브러리의 그룹 ID(Maven에서의 Group ID와 동일).
• artifact: 라이브러리 이름(Maven에서의 Artifact ID와 동일).
• version: 라이브러리의 버전.

예제: Spring Boot Starter Web

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:2.7.5'
}

위의 의존성은 다음과 같은 Maven 좌표를 나타냅니다:

• 그룹 ID: org.springframework.boot
• 아티팩트 ID: spring-boot-starter-web
• 버전: 2.7.5

2. 주요 의존성 범위 (Configuration)

1) implementation

• 설명: 애플리케이션 코드에서 사용하는 기본 의존성.
• 특징:
  • 의존성이 컴파일 및 런타임에 포함됩니다.
  • 하위 모듈에 전파되지 않습니다.
• 예제

implementation 'org.springframework.boot:spring-boot-starter-web'

2) api

• 설명: 라이브러리를 사용하는 외부 프로젝트에서 의존성을 노출해야 할 때 사용.
• 특징:
  • implementation과 달리 하위 모듈에서도 사용할 수 있도록 전파됩니다.
• 예제
  

api 'org.apache.commons:commons-lang3:3.12.0'

3) compileOnly

• 설명: 컴파일 시에만 필요한 의존성.
• 특징:
  • 런타임에는 포함되지 않습니다.
  • Lombok 같은 어노테이션 처리 라이브러리에서 주로 사용.
• 예제

compileOnly 'org.projectlombok:lombok:1.18.26'
annotationProcessor 'org.projectlombok:lombok:1.18.26'

4) runtimeOnly

• 설명: 런타임 시에만 필요한 의존성.
• 특징:
  • 컴파일 시에는 필요 없지만, 실행 중에만 사용됩니다.
• 예제

runtimeOnly 'mysql:mysql-connector-java:8.0.33'

5) testImplementation

• 설명: 테스트 코드에서만 사용하는 의존성.
• 특징:
  • JUnit, Mockito 등의 테스트 라이브러리에서 주로 사용.
• 예제

testImplementation 'org.springframework.boot:spring-boot-starter-test'

3. 다양한 의존성 선언 방식

1) 단일 문자열 형식

가장 일반적인 방식으로, Maven 좌표(group:artifact:version)를 명시합니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web:2.7.5'
}

2) version 생략

Spring Boot 프로젝트는 io.spring.dependency-management 플러그인을 통해 버전을 관리하므로, 일반적으로 버전을 생략합니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

3) 별도의 변수 사용

의존성 버전을 변수로 정의하면 관리가 용이합니다.

ext {
    springBootVersion = '2.7.5'
}
dependencies {
    implementation "org.springframework.boot:spring-boot-starter-web:$springBootVersion"
}

4) Maven BOM 사용

Maven BOM(Bill of Materials)을 사용해 여러 의존성의 버전을 일관되게 관리할 수 있습니다.

dependencyManagement {
    imports {
        mavenBom "org.springframework.boot:spring-boot-dependencies:2.7.5"
    }
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

5) 로컬 프로젝트 의존성

같은 프로젝트 내의 다른 모듈을 참조할 때 사용합니다.

dependencies {
    implementation project(':moduleA')
}

6) 로컬 파일 의존성

JAR 파일을 직접 참조해야 할 경우 사용합니다.

dependencies {
    implementation files('libs/my-library-1.0.0.jar')
}

4. 실무에서 유용한 팁

1) 의존성 트리 확인

gradle dependencies 명령어를 사용하면 프로젝트의 의존성 트리를 확인할 수 있습니다.

./gradlew dependencies

2) 의존성 충돌 해결

의존성 충돌이 발생할 경우, dependencyManagement 블록에서 우선순위를 설정하거나 특정 버전을 강제로 지정합니다.

dependencies {
    implementation 'com.google.guava:guava:31.1-jre'
    implementation 'org.example:conflicting-lib:1.2.3'
}

3) 선택적 의존성 추가

환경에 따라 특정 라이브러리를 추가하려면 Gradle의 조건문을 활용합니다.

dependencies {
    if (project.hasProperty('useMysql')) {
        runtimeOnly 'mysql:mysql-connector-java:8.0.33'
    } else {
        runtimeOnly 'org.postgresql:postgresql:42.6.0'
    }
}

5. 대표적인 의존성 예시

dependencies {
    // Spring Boot 의존성
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-security'

    // 데이터베이스
    runtimeOnly 'mysql:mysql-connector-java'
    runtimeOnly 'org.postgresql:postgresql'

    // 테스트 라이브러리
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.mockito:mockito-core:5.5.0'
}

[spring boot] build.gradle 설정 

1. 기본 구조

build.gradle 파일의 기본 구조는 다음과 같습니다.

plugins {
    id 'org.springframework.boot' version '3.4.2' // Spring Boot 플러그인
    id 'io.spring.dependency-management' version '1.1.7' // 의존성 관리 플러그인
    id 'java' // Java 플러그인
}

group = 'com.example' // 프로젝트 그룹 ID
version = '0.0.1-SNAPSHOT' // 프로젝트 버전

java {
    // Java Toolchain을 사용해 프로젝트에서 사용할 Java 버전을 설정합니다.
    toolchain {
        // Java 17 버전을 사용하도록 설정합니다.
        // Java 17은 LTS 버전으로 안정적이고 장기 지원이 제공됩니다.
        languageVersion = JavaLanguageVersion.of(17)
    }
}

configurations {
    // 'compileOnly'는 컴파일 시에만 필요한 의존성을 지정합니다.
    // 'annotationProcessor'의 설정을 상속받아 Lombok과 같은 의존성을 처리합니다.
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    // 프로젝트에 필요한 의존성을 다운로드할 리포지토리를 설정합니다.
    // 'mavenCentral()'은 오픈소스 라이브러리를 받을 수 있는 대표적인 Maven 리포지토리입니다.
    mavenCentral() // Maven 중앙 저장소
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter' // Spring Boot 핵심
    testImplementation 'org.springframework.boot:spring-boot-starter-test' // 테스트 라이브러리
}

2. 주요 구성 요소

1) 플러그인 설정

plugins 블록은 Gradle에서 사용하는 플러그인을 정의합니다.

• org.springframework.boot
  Spring Boot 애플리케이션을 Gradle로 빌드할 수 있게 해주는 플러그인.
• io.spring.dependency-management
  Spring Boot의 의존성 버전을 자동으로 관리합니다.
• java
  Java 빌드 도구를 활성화합니다.

2) 프로젝트 속성

• group: Maven 아티팩트의 그룹 ID.
• version: 애플리케이션 버전 정보.
• java 
  프로젝트에서 사용할 Java 버전을 설정합니다.

3) 저장소 설정

repositories 블록은 의존성을 가져올 저장소를 정의합니다.

• mavenCentral(): Maven Central 저장소.
• jcenter(): JCenter 저장소(현재는 사용되지 않는 경우가 많음).
• google(): Google 저장소(Android 관련 프로젝트에서 주로 사용).

4) 의존성 관리

dependencies 블록은 프로젝트에서 사용하는 라이브러리와 프레임워크를 정의합니다.

의존성 유형

• implementation: 런타임 및 컴파일 시 사용되는 의존성.
• compileOnly: 컴파일 시 필요하지만, 런타임에는 포함되지 않음.
• runtimeOnly: 런타임에만 필요한 의존성.
• testImplementation: 테스트 코드에서만 사용되는 의존성

의존성 예제

dependencies {
    // Spring Boot 핵심 의존성
    implementation 'org.springframework.boot:spring-boot-starter'

    // Spring Web (REST API 개발)
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // Spring Data JPA (데이터베이스와의 연동)
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // MySQL 데이터베이스 드라이버
    runtimeOnly 'mysql:mysql-connector-java'

    // 테스트 관련 의존성
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

3. 실무에서 자주 사용되는 항목

1) Lombok 플러그인 추가

Lombok은 Java 코드에서 반복되는 Getter, Setter 등을 줄이는 데 유용합니다.

dependencies {
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    
    // 테스트에서 사용하기 위한 의존성 
    testCompileOnly 'org.projectlombok:lombok'
    testAnnotationProcessor 'org.projectlombok:lombok'
}

2) 데이터베이스 연동

MySQL, PostgreSQL, H2와 같은 데이터베이스를 사용할 때 관련 드라이버를 추가합니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'mysql:mysql-connector-java'
}

3) Spring Security

Spring Security로 인증 및 권한 부여를 구현할 때 의존성을 추가합니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
}

4) Gradle Task 설정

빌드, 테스트, 실행 등의 작업을 커스터마이즈하려면 tasks 블록을 추가합니다.

tasks.named('test') {
    useJUnitPlatform() // JUnit 5 플랫폼 사용
}

[spring boot] jpa - mariadb application.properties 설정 

    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'

spring.datasource.url=jdbc:mariadb://localhost:3306/데이터베이스명?useSSL=false&useUnicode=true&serverTimezone=Asia/Seoul&allowPublicKeyRetrieval=true
spring.datasource.username=사용자 id 
spring.datasource.password=비밀번호 

spring.jpa.hibernate.ddl-auto=none
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
spring.jpa.open-in-view=false

다음은 주석을 추가한 내용입니다. 

spring.datasource.url=jdbc:mariadb://localhost:3306/데이터베이스명?useSSL=false&useUnicode=true&serverTimezone=Asia/Seoul&allowPublicKeyRetrieval=true
# MariaDB 데이터베이스의 연결 URL을 설정합니다.
# - 'localhost'는 데이터베이스 서버가 로컬 호스트에 있음을 나타냅니다.
# - '3306'은 MariaDB의 기본 포트 번호입니다.

# 추가적인 파라미터:
# - 'useSSL=false': SSL 연결을 사용하지 않도록 설정합니다.
# - 'useUnicode=true': 유니코드 문자셋을 사용하도록 설정합니다.
# - 'serverTimezone=Asia/Seoul': 서버의 시간대를 'Asia/Seoul'로 설정합니다.
# - 'allowPublicKeyRetrieval=true': 퍼블릭 키 검색을 허용합니다. 이는 비밀번호를 RSA로 암호화하여 전송할 때 필요합니다.

spring.datasource.username=사용자id
# 데이터베이스에 연결할 때 사용할 사용자 이름을 설정합니다.

spring.datasource.password=비밀번호
# 데이터베이스에 연결할 때 사용할 비밀번호를 설정합니다.
# 민감한 정보이므로 보안에 유의해야 합니다.


spring.jpa.hibernate.ddl-auto=none
# Hibernate가 데이터베이스 스키마를 자동으로 생성하거나 업데이트하지 않도록 설정합니다.
# 'none'으로 설정하면 애플리케이션 실행 시 스키마 변경을 수행하지 않습니다.
# 일반적으로 프로덕션 환경에서는 수동으로 스키마를 관리하기 위해 'none'으로 설정합니다.

# 설정값 설명
# none : 
#     Hibernate가 데이터베이스 스키마를 자동으로 생성하거나 갱신하지 않습니다. 
#     즉, 애플리케이션을 실행할 때 스키마 변경 작업을 수행하지 않습니다. 
# validate :     
#     애플리케이션 시작 시 엔티티 클래스와 기존 데이터베이스 스키마가 일치하는지 검증합니다. 일치하지 않을 경우 예외를 발생시킵니다. 
#     이 설정은 스키마를 변경하지 않고, 매핑의 정확성을 확인하는 데 사용됩니다.
# update :엔티티 클래스의 변경 사항을 기존 데이터베이스 스키마에 반영합니다. 
#     새로운 컬럼이나 테이블은 추가되지만, 기존의 데이터나 테이블은 삭제되지 않습니다. 
#     개발 중에 유용하지만, 프로덕션 환경에서는 주의해서 사용해야 합니다. 
# create :      
#     애플리케이션 시작 시 기존 데이터베이스의 테이블을 삭제하고, 엔티티 클래스에 기반하여 새로운 스키마를 생성합니다. 
#     모든 기존 데이터는 삭제되므로, 개발 초기 단계에서 주로 사용됩니다.
#     개발 중에 유용하지만, 프로덕션 환경에서는 주의해서 사용해야 합니다.
# create-drop: 
#     create와 유사하게 애플리케이션 시작 시 스키마를 생성하지만, 애플리케이션 종료 시 스키마를 삭제합니다. 
#     테스트 환경에서 유용하게 사용할 수 있습니다. 
#     반드시 테스트 환경에서만 사용하세요

spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
# Hibernate의 물리적 네이밍 전략을 지정합니다.
# 'PhysicalNamingStrategyStandardImpl'은 엔티티 필드명을 그대로 테이블의 컬럼명으로 매핑합니다.
# 이를 통해 엔티티 필드명과 데이터베이스 컬럼명이 일치하게 됩니다.

spring.jpa.open-in-view=false
# Open Session in View 패턴을 비활성화합니다.
# 기본값은 'true'이며, 이는 뷰 렌더링 시점까지 영속성 컨텍스트를 열어두어 지연 로딩이 가능하게 합니다.
# 하지만 이는 DB 커넥션을 장시간 점유할 수 있어 성능 이슈를 유발할 수 있으므로, 일반적으로 'false'로 설정하여 트랜잭션 범위 내에서만 영속성 컨텍스트를 유지하도록 합니다.

[spring boot] mybatis - mariadb application.yml 설정 

	// build.gradle dependencies
    
	implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3'
	runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
	testImplementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter-test:3.0.3'

# application.yml
# 서버 설정
server:
  port: 80  # 서버가 실행될 포트를 지정합니다. 여기서는 80번 포트를 사용합니다.

# Spring 프레임워크 설정
spring:
  datasource:  # 데이터베이스 연결 정보를 설정합니다.
    url: jdbc:mariadb://localhost:3306/databasename  # MariaDB 데이터베이스 연결 URL. databasename`라는 데이터베이스를 사용합니다.
    username: username  # 데이터베이스 접속에 사용할 사용자 이름입니다.
    password: password  # 데이터베이스 접속에 사용할 비밀번호입니다.

# MyBatis 설정
mybatis:
  configuration:
    map-underscore-to-camel-case: true  # 데이터베이스 필드 이름이 snake_case일 경우 Java 객체 필드 이름과 자동으로 매핑(camelCase)하도록 설정합니다.
  mapper-locations: classpath:mapper/**/*.xml  # MyBatis 매퍼 파일(.xml)의 위치를 지정합니다.