궁금한 이야기 IT

📌 [mybatis] resultType이 String인 경우 경고 메시지가 뜨네요

✔ Mybatis에서 DB정보를 이용하여 가공된 텍스트값을 받으려고 합니다. 

    <select id="getInfo" resultType="String">
        select 'abc'
    </select>

✔ 그런데 mapper interface에서 다음과 같은 경고메세지가 빨간줄과 함께 표시됩니다.

@Mapper 
public interface InfoMapper {
	String getInfo();
}

===============================================
Result type not match for select id="getInfo" 

srcType: java. lang. String 
targetType: java. lang. String
===============================================

분명 같은 타입인데도 말이죠. 

MyBatis에서 resultType="String"을 지정하면 "Result Maps collection does not have a type handler for result object" 또는 비슷한 경고 메시지가 발생할 수 있습니다. 이는 MyBatis가 반환할 데이터 타입을 명확하게 매핑하는 과정에서 발생하는 경고입니다.

📝 해결 방법

✅ resultType="java.lang.String"으로 명시

✔ 경고가 단순한 매핑 이슈라면 resultType="java.lang.String"처럼 패키지명을 명확하게 적어주는 것만으로도 해결되는 경우가 있습니다. 

    <select id="getInfo" resultType="java.lang.String">
        select 'abc'
    </select>

이 방법으로 해결이 안된다면..

✅ resultType="String" 대신 resultMap 사용

✔ MyBatis의 resultMap을 정의하고, 이를 select 문에서 참조하는 방식으로 해결할 수 있습니다.

<resultMap id="StringResultMap" type="java.lang.String"/>
<select id="getInfo" resultMap="StringResultMap">
    select 'abc'
</select>

저는 이방법으로 해결했습니다.  🤔

📌 [mariadb / mysql / mybatis ] Like문 사용방법 

✅ 회원테이블에서 김씨 성을 검색하는 방법입니다. 

select *
  from 회원테이블
 where member_id like '김%'

✅ Mybatis에서 변수로 처리하기 위해서 검색부분을 분리하면 검색이 안됩니다. 

select *
  from 회원테이블
 where member_id like '김' + '%'

✅ concat 함수를 이용하여 분리해야 합니다. 

select *
  from 회원테이블
 where member_id like concat('김', '%')

✅ 이제 Mybatis에서 parameter로 검색어를 받아서 조회할 수 있습니다. 

    <select id="findByMember" parameterType="String" resultType="Member">
        select member_id, member_name
        from member
        where member_name like concat(#{searchTxt},'%')
    </select>

[Java(자바)] 현재 날짜, 현재 시간 구하기 

✅ LocalDate 사용 (날짜만 필요할 때)

import java.time.LocalDate;

public class Main {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("현재 날짜: " + today);
        
        // 포맷 적용하기 
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
        String nowString = now.format(formatter);
        
        System.out.println("포맷팅 날짜: " + nowString);
        
    }
}

👉  출력 결과 

현재 날짜: 2025-03-04
포맷팅 날짜: 2025/03/04

✅ LocalDateTime 사용 (날짜와 시간 필요할 때)

import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println("현재 날짜와 시간: " + now);
    }
}

👉  출력 결과 

현재 날짜와 시간: 2025-03-04T14:30:45.123

✅ ZonedDateTime 사용 (시간대 포함)

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class Main {
    public static void main(String[] args) {
        ZonedDateTime seoulTime = ZonedDateTime.now(ZoneId.of("Asia/Seoul"));
        System.out.println("서울 시간: " + seoulTime);
    }
}

👉  출력 결과 

서울 시간: 2025-03-04T14:30:45.123+09:00[Asia/Seoul]

✅ Date 클래스 사용 (구버전(버전 8 이전), 권장X)

import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println("현재 날짜와 시간: " + date);
    }
}

👉  출력 결과 

현재 날짜와 시간: Tue Mar 04 14:30:45 KST 2025

📌 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)의 위치를 지정합니다.