[Spring][MyBatis][개념] 🚀 MyBatis와 Spring의 매끄러운 통합: SQL과 객체 매핑의 비밀 🔍

🔍 MyBatis 개요와 특징: SQL과 객체 매핑의 간편함

MyBatis는 Java 객체와 SQL 문을 자동으로 매핑하여 객체와 데이터베이스 간의 데이터를 주고받을 수 있도록 도와주는 ORM(Object Relational Mapping) 프레임워크입니다. SQL 쿼리를 직접 작성하고 관리하면서 객체 지향 프로그래밍의 장점을 취할 수 있다는 것이 큰 특징입니다. 각 항목별로 MyBatis의 주요 기능과 장점을 살펴보겠습니다.

---

📘 MyBatis의 주요 특징

1. Java Object와 SQL문 사이의 자동 Mapping 지원

• 설명: MyBatis는 Java 객체와 SQL 문 사이의 매핑을 자동으로 처리하여, Java 객체와 데이터베이스 간 데이터를 주고받는 과정을 간소화합니다.
• 장점: 개발자는 SQL 쿼리를 직접 작성하며, MyBatis가 Java 객체와 SQL 간의 데이터를 자동으로 매핑해 주기 때문에 객체 지향 프로그래밍과 SQL 사용의 장점을 동시에 누릴 수 있습니다.

2. SQL을 별도의 파일로 분리 관리

• 설명: SQL 쿼리는 보통 XML 파일 또는 외부 파일로 분리하여 관리할 수 있습니다.
• 장점: SQL 로직을 프로그램 코드와 분리하여, SQL 쿼리의 재사용성과 유지보수성을 높일 수 있습니다. 이는 SQL 쿼리를 독립적으로 관리하고 수정할 수 있어, 변경이 필요할 때 코드 전체를 수정할 필요 없이 SQL 파일만 업데이트하면 됩니다.

3. Parameter Mapping 자동화

• 설명: MyBatis는 Java 객체의 필드 값을 SQL 쿼리에 자동으로 전달하고, SQL 쿼리 결과를 Java 객체에 매핑하는 작업을 자동화합니다.
• 장점: 수작업으로 SQL에 값을 넣고 빼는 번거로움을 줄여 개발 생산성이 크게 향상됩니다. 예를 들어, 객체 속성들이 SQL 문의 WHERE 조건에 자동으로 매핑되어 코드가 깔끔해집니다.

4. 새로운 DB 프로그래밍 패러다임을 학습할 필요 없음

• 설명: Hibernate나 JPA와 같은 ORM 프레임워크는 SQL을 추상화하여 새로운 DB 프로그래밍 방식을 제공합니다. 반면 MyBatis는 SQL을 그대로 사용하기 때문에 새로운 패러다임을 학습할 필요가 없습니다.
• 장점: 개발자가 익숙한 SQL 문법을 그대로 사용할 수 있어, 기존 SQL에 익숙한 개발자들에게 특히 유리하며, SQL 기반의 자유로운 데이터베이스 접근을 유지할 수 있습니다.

5. JDBC의 불편함을 제거

• 설명: MyBatis는 SQL 쿼리와 Java 객체 간의 변환을 자동으로 처리하여, 복잡한 JDBC 코드를 작성할 필요가 없습니다.
• 장점: JDBC를 사용할 때 필요했던 복잡한 코드와 예외 처리를 줄이고, 간단한 코드로 SQL을 자유롭게 사용할 수 있게 해줍니다. 이는 코드의 간결성과 가독성을 크게 높여줍니다.

6. 도메인 객체나 VO 객체 중심의 개발

• 설명: MyBatis는 도메인 객체 또는 VO(Value Object)를 중심으로 데이터 처리를 합니다. 도메인 객체는 데이터베이스의 테이블과 1:1로 매핑되어 데이터 전송을 담당합니다.
• 장점: 데이터베이스 레코드와 Java 객체가 일대일로 매핑되기 때문에 객체 지향적인 설계와 데이터 관리를 쉽게 할 수 있습니다. 이는 구조화된 데이터 관리를 가능하게 하여 대규모 시스템에서 유리합니다.

---

🔍 MyBatis의 주요 특징: 간편성과 유연성의 ORM 프레임워크

MyBatis는 간단한 ORM(Persistence Framework)으로, JDBC의 복잡성을 줄이고 SQL과 Java 객체 간의 매핑을 자동화하여 효율적인 데이터베이스 처리를 가능하게 합니다. 특히 SQL 분리 관리와 다양한 언어 지원을 통해 유지보수성과 유연성을 높인 것이 특징입니다. 각 항목별로 MyBatis의 핵심 기능과 장점을 설명하겠습니다.

---

📘 MyBatis의 특징

1. 쉬운 접근성과 코드의 간결함

• 가장 간단한 Persistence Framework:

  • MyBatis는 ORM 중에서도 구조가 간단하고 직관적인 프레임워크로, 복잡한 설정 없이 쉽게 배워 사용할 수 있습니다.
  • 개발자는 SQL 문법에 익숙하다면 MyBatis 역시 쉽게 접근할 수 있습니다.

• JDBC 기능을 대부분 제공:

  • MyBatis는 SQL 쿼리를 XML 파일로 관리하면서도 JDBC의 기능을 거의 그대로 제공합니다.
  • 즉, SQL을 그대로 사용하면서도 JDBC의 번거로움은 줄어들어 개발자에게 익숙한 SQL 스타일을 유지하면서도 간편한 코드 작성을 지원합니다.

• 복잡한 JDBC 코드 제거로 깔끔한 소스코드 유지:

  • JDBC에서는 데이터 처리 시 복잡한 코드를 작성해야 하는데, MyBatis는 이러한 복잡함을 자동화하여 코드를 간결하게 유지할 수 있습니다.

• 자동 parameter 설정과 Query 결과 매핑:

  • MyBatis는 SQL 쿼리에 대한 parameter 설정과 쿼리 결과 매핑을 자동화합니다.
  • 개발자가 매번 값을 넣고 빼는 작업을 하지 않아도 되어 코드가 더 단순해지고 유지보수가 편리해집니다. 이는 개발 속도를 높이고 코드 가독성을 개선합니다.

---

2. SQL문과 프로그래밍 코드의 분리

• SQL 변경 시 Java 코드 수정 불필요:

  • MyBatis는 SQL 쿼리를 외부 XML 파일에 저장하여 관리하기 때문에, SQL 문법 변경 시 Java 코드를 수정하거나 컴파일할 필요가 없습니다.
  • 이로 인해 데이터베이스와 애플리케이션 로직 간의 독립성이 보장되고 유지보수가 용이합니다.

• SQL 작성과 검토를 전문 DBA에게 맡길 수 있음:

  • SQL과 코드가 분리되어 있어, SQL 쿼리를 개발자가 아닌 DBA(Database Administrator)와 같은 데이터베이스 전문가에게 맡길 수 있습니다.
  • 이는 개발자와 DBA 간의 역할 분담을 명확히 할 수 있어 효율적이며, SQL 쿼리 관리가 용이해집니다.

---

3. 다양한 프로그래밍 언어 지원

• Java, C#, .NET, Ruby 등 다양한 언어 지원:
  • MyBatis는 Java뿐 아니라 C#, .NET, Ruby와 같은 여러 프로그래밍 언어에서 사용 가능합니다.
  • 특정 언어에 종속되지 않고 다양한 언어와 플랫폼에서 활용할 수 있어 유연성과 확장성이 뛰어납니다. MyBatis는 이러한 언어 호환성을 통해 더 넓은 개발 환경에서 채택될 수 있는 장점이 있습니다.

---

MyBatis와 MyBatis-Spring을 사용한 DB 접근 구조: 주요 컴포넌트와 동작 원리

MyBatis와 MyBatis-Spring은 데이터베이스와 애플리케이션 간의 상호작용을 간소화하고, SQL과 객체 간의 매핑을 효율적으로 처리하도록 돕는 구조를 형성합니다. 이 아키텍처에서 각 컴포넌트가 어떻게 연결되고 역할을 수행하는지 하나씩 설명드리겠습니다.

---

1. Application Modules (애플리케이션 모듈)

• Service:

  • Service 계층은 애플리케이션의 비즈니스 로직을 수행하는 중심 역할을 합니다. 비즈니스 로직에 따라 데이터베이스의 정보를 요청하거나 저장해야 할 경우, Repository(Mapper)에 요청을 보내 데이터베이스와 상호작용합니다. 이를 통해 데이터가 비즈니스 로직에 맞게 처리됩니다.

• Repository (Mapper):

  • MyBatis의 Mapper는 SQL 쿼리를 Java 객체에 매핑해주는 역할을 합니다. Repository 계층에서는 이 Mapper를 통해 데이터베이스에 접근하여 쿼리를 실행하고, 그 결과를 Java 객체로 반환받습니다. Spring 환경에서는 Repository 인터페이스를 사용해 데이터베이스와의 상호작용을 더욱 관리하기 쉽게 만듭니다. 이 계층을 통해 애플리케이션 모듈이 데이터베이스와 간접적으로 연결됩니다.

---

2. O/R Mapper (객체-관계 매핑)

• MyBatis3:

  • MyBatis의 최신 버전인 MyBatis3는 객체와 SQL 쿼리 간의 매핑을 담당합니다. SQL 쿼리는 XML 파일이나 애노테이션 형태로 관리할 수 있어, 개발자는 Java 객체를 통해 데이터를 주고받을 수 있게 됩니다. 이로 인해 객체 지향 프로그래밍과 SQL 사용의 장점을 모두 취할 수 있습니다.

• MyBatis-Spring:

  • MyBatis-Spring은 MyBatis와 Spring 프레임워크를 통합하여 사용할 수 있도록 도와줍니다. 이 모듈을 사용하면 Spring의 트랜잭션 관리와 의존성 주입(Dependency Injection) 기능을 쉽게 활용할 수 있습니다. 이를 통해 Spring 애플리케이션에서 MyBatis를 매끄럽게 통합하고, 트랜잭션 관리와 같은 Spring의 주요 기능을 함께 사용할 수 있습니다.

---

3. JDBC Interfaces (JDBC 인터페이스)

• JDBC Basic APIs:

  • MyBatis는 내부적으로 JDBC API를 사용해 데이터베이스와의 상호작용을 수행합니다. JDBC는 Java에서 제공하는 표준 API로, 데이터베이스와 연결하고 SQL 쿼리를 실행하기 위해 사용됩니다. MyBatis는 JDBC API의 복잡한 부분을 추상화하여, 개발자가 직접 JDBC 코드를 작성하지 않고도 데이터베이스와의 연결과 쿼리 실행을 쉽게 할 수 있도록 지원합니다.

• DataSource (Configuration for Connect):

  • DataSource는 데이터베이스와의 연결을 관리하는 중요한 요소로, DB 연결 정보를 설정하고 연결 풀(Connection Pool)을 통해 효율적인 연결 관리를 가능하게 합니다. MyBatis와 Spring에서는 DataSource 설정을 통해 데이터베이스 연결을 최적화하며, 데이터베이스 자원을 효과적으로 사용하여 성능을 개선할 수 있습니다.

---

4. JDBC Implementations (JDBC 구현)

• JDBC Driver:
  • JDBC 드라이버는 Java 애플리케이션이 데이터베이스에 연결하고 상호작용할 수 있도록 도와주는 구성 요소입니다. 데이터베이스에 따라 각각의 고유한 JDBC 드라이버가 있으며, MyBatis는 이 드라이버를 사용해 SQL 쿼리를 데이터베이스에 전달하고 결과를 반환받아 처리합니다.

---

5. Persistence Layer (영속성 계층)

• Database (데이터베이스):
  • 데이터베이스는 MyBatis가 최종적으로 연결되어 데이터를 읽고 쓰는 대상입니다. JDBC 드라이버를 통해 SQL 쿼리를 전달하고, 데이터베이스에서 원하는 정보를 조회하거나 변경하는 작업을 수행합니다. MyBatis는 이를 통해 다양한 데이터베이스(MySQL, Oracle, PostgreSQL 등)와 연동할 수 있습니다.

---

🔍 MyBatis와 MyBatis-Spring을 활용한 Data Access Layer(데이터 접근 계층) 구조

MyBatis와 MyBatis-Spring을 활용한 데이터 접근 계층의 구조는 각 계층의 역할과 흐름을 명확히 나눠 데이터베이스와 애플리케이션 간의 상호작용을 간단하고 효율적으로 만듭니다. 아래 각 계층별로 주요 구성 요소와 그 동작을 설명하겠습니다.

---

1. Presentation Layer (프레젠테이션 계층)

• Controller:
  • 사용자의 요청을 가장 먼저 처리하는 진입점입니다. 사용자가 보내는 HTTP 요청을 받아 Service 계층에 전달하고, Service에서 처리한 응답을 사용자에게 반환합니다. 이 계층은 프론트엔드와 백엔드의 연결 지점 역할을 하며, 요청을 Service로 전달하여 실제 비즈니스 로직을 실행합니다.

---

2. Service Layer (서비스 계층)

• Service:
  • 비즈니스 로직이 수행되는 계층입니다. Service 계층은 비즈니스 요구 사항에 맞춰 데이터를 가공하고, 데이터베이스에 접근할 필요가 있을 때는 DAO 계층을 통해 데이터를 요청하거나 저장합니다. 이 계층에서 주로 트랜잭션 관리도 함께 수행됩니다.
• ServiceImpl:
  • Service 인터페이스의 실제 구현체로, 여기에서 실제 비즈니스 로직이 실행됩니다. DAO 객체는 의존성 주입(Dependency Injection, DI)을 통해 이 계층에 전달되며, 필요한 데이터를 가져오거나 업데이트하는 작업이 이루어집니다.

---

3. Data Access Layer (데이터 접근 계층)

• DAO (Data Access Object):
  • 데이터베이스와 직접적으로 상호작용하여 데이터를 가져오거나 저장하는 역할을 합니다. Service 계층이 필요한 데이터를 요청하면 DAO가 SQL 쿼리를 실행하여 데이터를 반환합니다. DAO는 인터페이스 형태로 작성되며, 구현체는 DAOImpl을 통해 정의됩니다.
• DAOImpl:
  • DAO의 실제 구현체로 MyBatis를 사용하여 SQL 쿼리를 실행하고, 데이터베이스와의 상호작용을 수행합니다. SqlSession 객체를 통해 SQL 쿼리가 실행되며, 데이터베이스에서 받은 결과는 Java 객체 형태로 반환됩니다.

---

4. MyBatis Framework (MyBatis 프레임워크)

• SqlSession:
  • MyBatis의 핵심 객체로, SQL 쿼리를 실행하고 데이터베이스와의 연결을 관리합니다. select, insert, update, delete와 같은 SQL 명령을 실행하며, 그 결과를 Java 객체로 반환해 데이터와 객체 간의 매핑을 도와줍니다.
• SqlSessionFactory:
  • SqlSession을 생성하는 팩토리 객체로, MyBatis 설정 파일(sqlMapConfig.xml)을 기반으로 SqlSession을 만듭니다. 이 객체는 MyBatis와 데이터베이스 간의 연결을 초기화하는 중요한 역할을 하며, 한 번 설정된 이후로는 필요할 때마다 새로운 SqlSession을 제공합니다.
• sqlMapConfig.xml:
  • MyBatis의 설정 파일로, 데이터베이스 연결 정보 및 매퍼 파일 경로 등을 설정합니다. MyBatis가 동작하는 데 필요한 기본적인 설정이 정의되며, SQL 쿼리와 매핑 작업을 수행하기 위한 설정 정보들이 포함됩니다.
• mapper.xml:
  • SQL 쿼리와 Java 객체 간의 매핑을 정의하는 매퍼 파일입니다. 각 SQL 쿼리가 어떻게 Java 객체에 매핑되는지를 정의하며, select 쿼리의 경우 쿼리 결과가 어느 Java 객체에 매핑될지 설정할 수 있습니다.
• dbinfo.properties:
  • 데이터베이스 연결에 필요한 정보가 담긴 프로퍼티 파일입니다. 데이터베이스 URL, 사용자 이름, 비밀번호 등이 포함되며, 외부 파일로 관리하여 환경 설정을 쉽게 변경할 수 있습니다.

---

5. Database (데이터베이스)

• 데이터베이스는 최종적으로 MyBatis가 JDBC 드라이버를 통해 연결하여 데이터를 처리하는 대상입니다. SqlSession을 통해 데이터베이스에 접근하여 SQL 쿼리를 실행하고, 쿼리 결과는 다시 애플리케이션으로 반환됩니다. MySQL, Oracle, PostgreSQL 등 다양한 데이터베이스와 연결이 가능합니다.

---

🌐 다이어그램의 데이터 흐름

• 녹색 화살표 (DI, 의존성 주입): ServiceImpl에 DAO 객체가 주입되며, 이를 통해 데이터베이스와의 간접적인 상호작용이 가능합니다.
• 빨간색 화살표 (request, 요청): 사용자의 요청이 Controller에서 시작되어 Service 계층으로 전달되고, 다시 DAO 계층으로 이어집니다.
• 보라색 화살표 (wiring, 연결): SqlSessionFactory가 SqlSession을 생성하고, SqlSession이 데이터베이스와 연결될 수 있도록 설정을 관리합니다.
• 회색 화살표 (DB access, 데이터베이스 접근): SqlSession을 통해 데이터베이스에 접근하여 SQL 쿼리를 실행하고, 결과를 가져오는 흐름입니다.

---

🔍 MyBatis와 MyBatis-Spring의 SQL 실행 프로세스와 주요 컴포넌트

이 구조는 MyBatis의 SQL 실행 프로세스를 설명하며, 각 컴포넌트가 어떻게 상호작용하는지를 보여줍니다. MyBatis와 Spring의 통합을 통해 애플리케이션에서 데이터베이스와의 상호작용을 효율적으로 처리할 수 있습니다. 각 컴포넌트의 역할과 데이터 흐름을 자세히 설명하겠습니다.

---

MyBatis 주요 Component

1. MyBatis Config File (설정 파일)

• 설명: MyBatis의 설정 파일로, 데이터베이스 연결 정보, 매퍼 파일 위치, 기타 MyBatis 동작 설정이 포함되어 있습니다. 이 파일을 통해 MyBatis가 SQL 쿼리와 객체 매핑을 수행하는 데 필요한 모든 설정을 읽어들입니다.
• 역할: 애플리케이션이 처음 실행될 때 MyBatis의 초기화 작업을 담당하여, 올바른 설정에 따라 MyBatis가 동작할 수 있도록 돕습니다.

---

2. SqlSessionFactoryBuilder (처음 한 번 실행되는 프로세스)

• 설명: SqlSessionFactoryBuilder는 MyBatis 설정 파일을 기반으로 SqlSessionFactory를 생성하는 빌더 객체입니다.
• 역할: 애플리케이션 시작 시 한 번만 실행되며, 설정 파일을 읽어 SqlSessionFactory 객체를 만듭니다. 이를 통해 SqlSessionFactory는 MyBatis의 핵심적인 데이터베이스 연결 객체가 됩니다.

---

3. SqlSessionFactory

• 설명: SqlSessionFactory는 SqlSession 객체를 생성하는 팩토리 역할을 합니다. 다수의 요청을 처리하기 위해 여러 SqlSession을 생성할 수 있습니다.
• 역할: MyBatis의 데이터베이스 접근을 관리하며, 각 요청마다 필요한 SqlSession 객체를 생성하여 데이터베이스와의 연결을 관리합니다.

---

4. Application (애플리케이션 - 요청마다 실행되는 프로세스)

• 설명: 애플리케이션은 사용자의 요청을 처리하고, 필요한 데이터를 조회하거나 업데이트하는 작업을 수행합니다.
• 역할: 사용자의 요청이 들어오면 SqlSessionFactory에서 SqlSession을 생성하여, 필요한 데이터를 데이터베이스에서 가져오거나 저장하는 과정을 거칩니다.

---

5. SqlSession (요청마다 실행되는 프로세스)

• 설명: SqlSession은 MyBatis가 데이터베이스와 상호작용할 때 사용하는 객체입니다. SQL 쿼리를 실행하고, 결과를 Java 객체로 변환하여 반환합니다.
• 역할: 매핑 파일을 참고하여 SQL 쿼리를 실행하고, 쿼리 결과를 Java 객체 형태로 반환합니다. 각 요청마다 생성되어 종료 시 닫히는 구조로, 요청별로 데이터베이스와의 독립적인 연결을 유지합니다.

---

6. Mapping File (매핑 파일 - 요청마다 실행되는 프로세스)

• 설명: 매핑 파일은 SQL 쿼리와 Java 객체 간의 매핑을 정의하는 XML 파일입니다.
• 역할: SQL 쿼리와 Java 객체의 매핑 규칙을 설정하여, MyBatis가 SQL 실행 시 입력 값과 결과 값을 자동으로 매핑하도록 돕습니다. 각 쿼리가 어떤 객체에 매핑될지를 이 파일에서 정의합니다.

---

7. Database (데이터베이스)

• 설명: 최종적으로 MyBatis는 데이터베이스와 연결하여 SQL 쿼리를 실행하고, 데이터베이스에서 결과를 받아 애플리케이션에 전달합니다.
• 역할: SqlSession을 통해 데이터베이스와의 상호작용이 이루어지며, 필요한 데이터를 조회하거나 저장, 업데이트하는 모든 작업이 이곳에서 수행됩니다.

---

데이터 흐름 설명

1. 한 번 실행되는 프로세스:

   • 애플리케이션이 시작될 때 MyBatis Config File을 읽어 MyBatis가 초기화됩니다.
   • SqlSessionFactoryBuilder가 설정 파일을 기반으로 SqlSessionFactory를 생성합니다. 이는 애플리케이션 시작 시에만 한 번 실행됩니다.

2. 요청마다 실행되는 프로세스:

   • 사용자가 요청을 보낼 때마다, 애플리케이션은 SqlSessionFactory를 통해 새로운 SqlSession을 생성합니다.
   • SqlSession은 매핑 파일을 참조하여 SQL 쿼리를 실행하고, 그 결과를 Java 객체로 반환합니다.
   • 각 요청마다 새로운 SqlSession이 생성되고, 작업이 완료되면 종료됩니다.
   • SQL 쿼리가 실행되면 데이터베이스에서 그 결과를 받아 애플리케이션에 반환하여 사용자의 요청을 처리합니다.

---

🔍 MyBatis와 MyBatis-Spring의 주요 컴포넌트 설명

MyBatis는 SQL 쿼리와 객체 간의 매핑을 자동화하여 데이터베이스와 애플리케이션 간 상호작용을 간편하게 합니다. MyBatis-Spring은 Spring 프레임워크와 MyBatis의 통합을 도와, 데이터베이스 연결과 설정을 효율적으로 관리할 수 있습니다. 각 컴포넌트가 어떻게 역할을 수행하는지 하나씩 살펴보겠습니다.

---

MyBatis와 MyBatis-Spring의 주요 Component

1. MyBatis 설정 파일 (sqlMapConfig.xml)

• 역할:
  • MyBatis 설정 파일은 MyBatis가 데이터베이스에 접근하고 SQL을 실행하는 방식을 설정하는 중요한 파일입니다.
  • 데이터베이스 접속 정보(URL, 사용자 이름, 비밀번호)와 객체의 별칭 설정, 매핑 파일 위치 등 MyBatis가 동작하는 데 필요한 기본 정보를 정의합니다.
  • 이 파일은 MyBatis가 애플리케이션 실행 시 각종 설정을 참조할 수 있도록 하여, 애플리케이션 시작 시 MyBatis의 초기화 작업에 사용됩니다.

---

2. SqlSessionFactoryBuilder

• 역할:
  • SqlSessionFactory를 생성하는 빌더 클래스입니다. MyBatis 설정 파일을 기반으로 SqlSessionFactory를 초기화하는 작업을 수행합니다.
  • 이 빌더는 애플리케이션이 시작될 때 한 번만 실행되며, SqlSessionFactory를 생성하여 MyBatis의 전반적인 설정을 초기화합니다.
  • 이 객체가 설정 파일을 읽어들여, 애플리케이션이 시작될 때 필요한 SqlSessionFactory를 자동으로 생성해 주므로, 개발자가 수동으로 각종 설정을 처리하지 않아도 됩니다.

---

3. SqlSessionFactory

• 역할:
  • SqlSession 객체를 생성하는 팩토리로, MyBatis의 핵심 구성 요소 중 하나입니다. 애플리케이션이 SQL 쿼리를 실행할 때마다 새로운 SqlSession을 생성하여 제공합니다.
  • Thread-safe하여 여러 쓰레드에서 안전하게 사용할 수 있습니다. 애플리케이션 시작 시 한 번 생성된 후, 필요할 때마다 새로운 SqlSession을 만들어 제공합니다.
  • SqlSessionFactory를 통해 생성된 SqlSession은 데이터베이스와의 연결을 관리하고 SQL을 실행하는 역할을 수행합니다.

---

4. SqlSession

• 역할:
  • SQL 실행과 트랜잭션 관리를 담당하는 MyBatis의 핵심 클래스입니다. MyBatis가 데이터베이스와 상호작용할 때 필요한 SQL 쿼리 실행, 트랜잭션 처리 등의 기능을 수행합니다.
  • Thread-safe하지 않으므로 요청마다 새로운 SqlSession 객체가 생성되어야 합니다. 각 요청이 독립적으로 데이터베이스와 상호작용할 수 있도록, 매 요청 시 SqlSession이 열리고 작업 완료 후 닫히는 구조로 사용됩니다.
  • 이 객체는 SQL 실행과 더불어, 매핑 파일에 정의된 규칙에 따라 SQL의 입력과 출력 데이터를 Java 객체와 자동으로 변환하여 애플리케이션에 반환합니다.

---

5. Mapping 파일 (예: member.xml)

• 역할:
  • MyBatis에서 사용하는 매핑 파일로, SQL 쿼리와 Java 객체 간의 매핑 규칙을 정의합니다.
  • 이 파일에는 SQL 쿼리와 각 쿼리의 결과를 Java 객체에 매핑하는 규칙이 포함되어 있습니다. 예를 들어, select 쿼리의 결과를 특정 Java 객체의 필드에 자동으로 매핑할 수 있는 설정이 이 파일에 담겨 있습니다.
  • 매핑 파일은 XML 형식으로 작성되며, 객체와 SQL 간의 매핑 작업을 간단하게 처리할 수 있어 SQL 결과를 쉽게 Java 객체로 변환할 수 있게 합니다.

---

🔍 MyBatis-Spring 통합: 주요 컴포넌트와 역할

MyBatis-Spring 통합 구조는 MyBatis와 Spring이 함께 작동하여 SQL 쿼리 실행, 트랜잭션 관리, 데이터베이스 연결을 효율적으로 처리하는 방법을 보여줍니다. 각 컴포넌트가 어떤 역할을 하며, 어떻게 상호작용하는지 자세히 설명하겠습니다.

---

MyBatis-Spring의 주요 Component

1. SpringBean 설정 파일 (member.xml)

• 설명: SpringBean 설정 파일은 MyBatis와 Spring이 함께 사용할 때 필요한 모든 설정을 담고 있는 XML 파일입니다.
• 역할: 이 파일은 MyBatis의 매퍼 파일을 로드하고, DataSource 및 SqlSessionFactory 등 데이터베이스 접근을 위한 Bean을 설정하여 Spring 애플리케이션에서 필요한 Bean을 초기화하고 관리합니다.

---

2. SqlSessionFactoryBean

• 설명: MyBatis-Spring의 핵심 Bean으로, SqlSessionFactory를 생성하는 역할을 합니다.
• 역할: Spring 환경에서 SqlSessionFactory를 생성하고 관리합니다. 이를 통해 MyBatis의 SqlSessionFactory가 Spring의 트랜잭션 관리, 연결 풀 설정과 같은 기능과 통합되어, SQL 세션이 Spring 트랜잭션 관리 하에 작동할 수 있습니다.

---

3. SqlSessionFactory

• 설명: SqlSessionFactory는 SqlSession 객체를 생성하는 MyBatis의 핵심 요소입니다.
• 역할: SQL 쿼리를 실행할 때마다 SqlSession을 생성하여 SQL 실행을 지원합니다. Spring 환경에서는 SqlSessionTemplate과 함께 사용되어, 안전하게 트랜잭션을 처리하면서 SQL 쿼리를 실행할 수 있도록 합니다.

---

4. SqlSessionTemplate

• 설명: SqlSessionTemplate은 SqlSession 인터페이스를 구현한 Spring Bean으로, Spring과 MyBatis 간의 상호작용을 돕는 주요 클래스입니다.
• 역할: SQL 쿼리 실행에 필요한 메서드(commit(), rollback(), insert(), delete(), selectOne(), selectList() 등)를 통해 트랜잭션 관리와 SQL 실행을 처리합니다. SqlSessionTemplate을 사용하면 Spring의 트랜잭션 관리 기능을 그대로 사용할 수 있어, 데이터베이스 작업이 안전하게 이루어집니다.

---

5. SqlSession 인터페이스

• 설명: MyBatis의 핵심 인터페이스로, SQL 쿼리 실행과 트랜잭션 관리를 수행합니다.
• 역할: SQL 실행을 포함하여 쿼리 결과를 Java 객체로 변환하는 기능을 제공하며, Spring에서는 SqlSessionTemplate이 이 인터페이스를 구현하여 SQL 쿼리 실행을 안전하게 관리합니다.

---

6. MyBatis 설정 파일 (sqlMapConfig.xml)

• 설명: MyBatis의 설정 파일로, 데이터베이스 연결 정보와 MyBatis의 동작 방식을 정의합니다.
• 역할: MyBatis가 SQL을 실행하는 데 필요한 다양한 설정 정보를 포함하여, 데이터베이스 연결 정보, 매퍼 파일 경로, 트랜잭션 설정 등이 이 파일에 정의됩니다. Spring 애플리케이션에서 MyBatis의 기능을 사용하는 데 필요한 기본 설정을 제공합니다.

---

7. Mapping 파일 (member.xml)

• 설명: SQL 쿼리와 Java 객체 간의 매핑을 정의하는 MyBatis의 매핑 파일입니다.
• 역할: 각 SQL 쿼리가 어떤 Java 객체에 매핑되는지 규칙을 설정합니다. 매핑 파일을 통해 쿼리 결과가 자동으로 Java 객체에 변환되어 반환되므로, 개발자는 매핑 설정만으로 SQL과 Java 객체 간의 데이터 변환을 쉽게 처리할 수 있습니다.

---

8. DataSource

• 설명: 데이터베이스와의 연결을 관리하는 Spring의 DataSource 객체입니다.
• 역할: 연결 풀을 관리하여 데이터베이스 연결을 효율적으로 제어합니다. Spring의 트랜잭션 관리와 함께 작동하여, 데이터베이스 연결의 안정성과 성능을 높입니다. 이를 통해 여러 연결이 동시에 열리고 닫히는 과정을 관리하여 애플리케이션의 성능을 유지합니다.

---

9. MemberDaoImpl

• 설명: DAO(Data Access Object)의 구현체로, 실제로 데이터베이스에 접근하여 데이터를 처리하는 역할을 합니다.
• 역할: SqlSessionTemplate을 사용하여 SQL 쿼리를 실행하고 데이터를 관리합니다. 예를 들어, 사용자 정보를 검색하는 search(userid)나 회원을 등록하는 register(MemberDto) 등의 메서드를 통해 데이터베이스 작업을 수행합니다.

---

🌟 MyBatis-Spring의 주요 컴포넌트와 역할 🎯

MyBatis-Spring은 MyBatis와 Spring이 통합되어 SQL 쿼리 실행, 트랜잭션 관리, 데이터베이스 연결을 손쉽게 관리할 수 있도록 하는 프레임워크입니다. 이 표는 MyBatis-Spring의 핵심 구성 요소들을 설명하며, 각 컴포넌트가 어떤 역할을 수행하는지 보여줍니다. 하나씩 살펴보며 이해해보겠습니다! 👀

---

🛠️ MyBatis-Spring의 주요 Component

1. MyBatis 설정 파일 (sqlMapConfig.xml)

• 설명:
  • MyBatis 설정 파일은 Dto 객체의 별칭(alias)과 데이터베이스 연결 정보를 포함하여 MyBatis가 필요한 모든 설정을 담고 있는 파일입니다. 이 파일을 통해 MyBatis는 SQL과 Java 객체 간의 매핑 작업을 자동화할 수 있습니다.
• 역할:
  • MyBatis가 SQL 쿼리를 실행하고 객체와 매핑할 수 있는 환경을 설정하며, 데이터베이스에 접근하는 기본 경로를 제공합니다.
  • 예를 들어, 데이터베이스 연결 URL과 매핑 파일 경로가 여기에 설정됩니다.

---

2. SqlSessionFactoryBean

• 설명:
  • SqlSessionFactory를 생성하는 역할을 하는 Spring Bean입니다.
  • 이 Bean은 MyBatis 설정 파일을 기반으로 SqlSessionFactory를 생성하여 Spring 애플리케이션에서 사용할 수 있게 합니다.
• 역할:
  • MyBatis의 SQL 세션 생성을 담당하며, Spring의 트랜잭션 관리와 연동되어 데이터베이스와의 연결을 제어합니다.
  • SQL 쿼리 실행을 위한 기본 환경을 제공합니다. 애플리케이션이 시작될 때 Spring Bean으로 등록되어, 트랜잭션이 안정적으로 유지될 수 있도록 돕습니다.

---

3. SqlSessionTemplate

• 설명:
  • SqlSessionTemplate은 MyBatis에서 SQL 쿼리를 실행하고 트랜잭션을 관리하는 역할을 합니다.
  • SqlSession 인터페이스를 구현하여 Thread-safe하게 동작하며, 여러 요청에서 안전하게 사용할 수 있습니다.
• 역할:
  • selectOne(), selectList(), insert(), update(), delete() 등의 다양한 SQL 메서드를 지원하여 쿼리 실행을 간편하게 합니다.
  • Spring의 트랜잭션 처리와 SQL 실행을 동시에 처리하며, MyBatis와 Spring이 안전하게 통합될 수 있도록 돕습니다.

---

4. Mapping 파일 (member.xml)

• 설명:
  • MyBatis에서 SQL 쿼리와 Java 객체 간의 매핑(ORM)을 설정하는 XML 파일입니다.
• 역할:
  • 각 SQL 쿼리와 그 결과를 어떤 Java 객체와 연결할지를 정의하여, SQL 결과를 자동으로 Java 객체로 변환할 수 있게 합니다.
  • 예를 들어, 특정 사용자 정보를 조회할 때 select 쿼리 결과가 MemberDto 객체에 매핑될 수 있도록 설정합니다.
  • 이 매핑 파일을 통해 객체와 SQL 쿼리 간의 매핑이 효율적이고 직관적으로 처리됩니다.

---

5. Spring Bean 설정 파일 (beans.xml)

• 설명:
  • Spring 애플리케이션에서 필요한 모든 Bean을 정의하는 XML 파일입니다.
• 역할:
  • SqlSessionFactoryBean, SqlSessionTemplate, DataSource 정보 및 MyBatis 설정 파일을 Spring Bean으로 등록하여, MyBatis와 Spring이 통합된 환경에서 동작할 수 있게 설정합니다.
  • 이를 통해 DataSource, SqlSessionFactory, SqlSessionTemplate 등의 객체들이 안정적으로 관리되고, 데이터베이스 연결과 SQL 매핑이 원활하게 이루어집니다.

---

🎯 MyBatis3의 Mapper Interface: 개념과 역할

MyBatis3에서 도입된 Mapper Interface는 MyBatis가 SQL을 더 안전하고 효율적으로 호출할 수 있도록 지원하는 중요한 구성 요소입니다. 이 인터페이스는 SQL 쿼리를 Java 코드로 안전하게 호출할 수 있게 해주며, SQL과 Java 객체 간의 매핑 작업을 쉽게 관리할 수 있도록 돕습니다. 아래에서 각 항목별로 자세히 설명드리겠습니다! 🚀

---

💡 MyBatis3의 Mapper Interface 주요 개념

1. Mapper Interface란?

• 설명:
  • Mapper Interface는 MyBatis에서 SQL 쿼리를 호출하기 위한 인터페이스입니다. MyBatis는 SQL 쿼리를 XML 파일에 별도로 정의하는데, 이를 Java의 인터페이스로 호출할 수 있도록 설정할 수 있습니다. 즉, 매핑된 SQL을 Java 코드에서 쉽게 호출할 수 있게 해주는 구조입니다.
• 역할:
  • MyBatis는 SQL 쿼리를 매핑 파일에 정의하고, Java 코드에서는 Mapper Interface를 통해 그 SQL을 호출할 수 있도록 지원합니다. 이를 통해 SQL 쿼리를 코드에서 직접 작성하지 않고, 별도의 파일로 관리할 수 있어 유지보수와 재사용성을 높입니다.

---

2. 타입 안전성(Type Safe)을 보장하는 SQL 호출

• 설명:
  • Mapper Interface는 MyBatis 3.x부터 도입되어 타입 안전성(Type Safety)을 보장하기 위한 장치를 제공합니다. 이는 SQL 쿼리를 실행할 때 발생할 수 있는 데이터 타입의 오류를 줄여주어, 안전하고 신뢰성 높은 코드를 작성할 수 있게 해줍니다.
• 역할:
  • 타입 안전성이란, 컴파일 타임에 데이터 타입을 확인하여 실행 중 발생할 수 있는 타입 오류를 방지하는 것을 의미합니다. 기존에는 SQL 호출 시 String 타입으로 관리되어 런타임 오류가 빈번했지만, Mapper Interface를 사용하면 컴파일 단계에서 이러한 오류를 사전에 잡아낼 수 있습니다.
  • 예를 들어: selectUserById(int userId)와 같은 메서드를 통해 userId가 int 타입임을 명확히 하여, SQL 호출 시 타입 오류가 발생하지 않도록 합니다.

---

3. 매핑 파일과의 연결

• 설명:
  • Mapper Interface는 매핑 파일에 정의된 SQL 쿼리와 Java 코드 간의 연결을 담당합니다. 매핑 파일에서 SQL이 정의되면, 이를 Mapper Interface를 통해 호출하여 Java 코드에서 간편하게 사용할 수 있습니다.
• 역할:
  • 매핑 파일에서 SQL 쿼리의 논리적 흐름과 매핑 규칙을 정의한 뒤, Java의 Mapper Interface에서 해당 쿼리를 호출할 수 있도록 연결합니다.
  • 이로써 SQL 쿼리와 Java 객체 간의 매핑 작업을 간편하고 직관적으로 처리할 수 있어, 개발자에게 매우 유연한 코드 작성 환경을 제공합니다.

---

🔍 Mapper Interface를 사용하지 않았을 때의 문제점

MyBatis3에서 Mapper Interface를 사용하지 않으면 발생하는 여러 문제점들이 있습니다. 이러한 문제점들은 코드의 안전성과 효율성을 떨어뜨리며, 개발 환경에서의 불편함을 초래할 수 있습니다. 아래에서 각 부분을 상세히 설명드리겠습니다!

---

🔸 Mapper Interface 미사용 시 발생하는 문제들

1. SQL 호출 방식

• 설명:
  • Mapper Interface 없이 SQL을 호출하면, SqlSession 객체의 메서드를 직접 호출하며, SQL 쿼리를 문자열로 전달해야 합니다.
  • 예를 들어 session.selectOne("com.ssafy.MemberDao.search", userid)와 같은 방식으로 네임스페이스(namespace)와 SQL ID를 결합한 문자열을 SQL 식별자로 사용합니다.
• 문제점:
  • 이 방식은 문자열을 사용하기 때문에 오타나 잘못된 문자열로 인해 오류가 발생할 수 있으며, 이러한 오류는 컴파일 단계에서 확인되지 않으므로 런타임에서만 문제가 드러납니다.
  • 또한, SQL 호출 방식이 복잡해져 코드의 가독성과 유지보수성이 떨어집니다.

---

2. Namespace + SQL ID로 지정

• 설명:
  • Mapper Interface가 없을 경우, SQL 쿼리를 호출할 때 네임스페이스와 SQL ID를 조합하여 SQL을 식별해야 합니다.
  • 예를 들어, com.ssafy.MemberDao는 네임스페이스이고 search는 SQL ID로, 이 둘을 "namespace + '.' + SQL ID" 형식으로 문자열에 지정해야 합니다.
• 문제점:
  • SQL 쿼리를 호출할 때마다 문자열로 네임스페이스와 SQL ID를 명시해야 하므로 반복적인 문자열 사용으로 인해 코드가 장황해지고 오류가 발생할 확률이 높아집니다.
  • 이 방식은 SQL ID가 중복되거나 변경될 경우 문제를 발생시키며, 네임스페이스와 ID 관리가 어려워질 수 있습니다.

---

3. 문자열 기반 호출의 문제점

• 설명:
  • SQL 쿼리를 호출하는 방식이 문자열 기반이기 때문에, 오타나 잘못된 값으로 인한 오류가 발생할 가능성이 큽니다. 이와 같은 실수는 컴파일 단계에서 감지되지 않으며, 런타임에서만 오류가 발생합니다.
  • 또한, 문자열을 사용하기 때문에 IDE의 코드 보조 기능(code assist), 예를 들어 자동완성이나 검색 기능의 지원을 받지 못합니다.
• 문제점:
  • 타입 안전성이 보장되지 않으므로 런타임 오류 발생률이 높아집니다.
  • 개발 편의성이 크게 떨어집니다. 예를 들어, Mapper Interface를 사용하면 IDE에서 쿼리와 파라미터에 대한 자동완성 기능을 지원받을 수 있지만, 문자열 기반에서는 이를 사용할 수 없습니다.

---

🔹 매퍼 XML 파일 설명

• 매퍼 파일은 MyBatis에서 SQL 쿼리와 Java 객체 간의 매핑 규칙을 정의한 XML 파일입니다.
• 예시의 <mapper namespace="com.ssafy.MemberDao">는 네임스페이스를 지정하여, 이 파일에 정의된 SQL 쿼리들이 com.ssafy.MemberDao라는 네임스페이스 하에서 관리되도록 합니다.
• <select id="search" parameterType="String">는 SQL 쿼리를 정의한 부분으로, 여기서 search는 SQL ID이며, 매개변수 타입은 "String"입니다. 이 쿼리는 userid라는 매개변수를 받아 데이터베이스에서 사용자 정보를 검색하는 역할을 합니다.

---

⚠️ 문제점 요약

• 오타 위험: 문자열을 사용하여 SQL을 식별하므로, 네임스페이스나 SQL ID를 잘못 입력하면 컴파일 타임에 감지되지 않고 런타임에만 오류가 드러납니다.
• IDE 지원 부족: 문자열 기반 방식에서는 자동완성, 타입 확인 등의 IDE 코드 보조 기능을 사용할 수 없어, 개발 편의성이 낮아집니다.

---

🔍 MyBatis3의 Mapper Interface 사용 시 구조와 작동 방식

MyBatis3에서 Mapper Interface를 사용하면, SQL 호출이 더욱 안전하고 간편해집니다. 이 구조는 MyBatis가 SQL과 Java 메서드를 자동으로 매핑하여 코드를 간결하게 유지하면서도 타입 안전성을 보장할 수 있게 합니다. 아래에서 각 구성 요소와 그 역할을 상세히 설명드리겠습니다. 😊

---

🌟 MyBatis3의 Mapper Interface 사용 시 구성 요소와 역할

1. Mapper Interface를 통한 SQL 호출

• 설명:
  • Mapper Interface를 사용하면 SQL 쿼리를 직접 문자열로 지정할 필요 없이 인터페이스 메서드 호출만으로 SQL을 실행할 수 있습니다.
• 예시:
  • userMapper.search(userid)와 같이, userMapper라는 인터페이스 인스턴스의 메서드 호출을 통해 SQL을 실행하며, userid를 매개변수로 전달할 수 있습니다.
• 장점:
  • SQL 호출이 간결해지고 코드의 가독성이 높아지며, 오류 가능성이 줄어듭니다.

---

2. 인터페이스와 매핑된 SQL

• 설명:
  • MyBatis는 Mapper Interface와 매핑 파일(XML)을 자동으로 연결합니다. Mapper Interface의 메서드가 호출될 때, MyBatis는 매핑 파일에서 해당 메서드와 연결된 SQL 쿼리를 찾아 자동으로 실행합니다.
• 구조:
  • 매핑 파일에서 <mapper namespace="com.ssafy.dao.UserMapper">는 네임스페이스를 정의하여 Mapper Interface와의 연결을 설정하고, <select id="search" parameterType="String">는 SQL ID와 매개변수 타입을 정의하여 search(userid) 메서드가 SQL 쿼리와 연결되도록 합니다.

---

3. UserMapper Interface의 구성

• 설명:
  • UserMapper 인터페이스는 개발자가 작성한 Mapper Interface로, 데이터베이스와 상호작용할 SQL 메서드를 정의합니다.
• 구성 요소:
  • search라는 메서드는 userid라는 문자열을 매개변수로 받아 SQL 쿼리와 직접 연결됩니다.
• 장점:
  • 타입 안전성이 보장되며, IDE에서 제공하는 코드 보조 기능을 통해 오류를 줄이고 코드 작성이 편리해집니다.

---

4. Namespace와 SQL ID 구성

• 설명:
  • MyBatis에서는 매핑 파일과 인터페이스가 정확히 연결될 수 있도록 Namespace와 SQL ID를 설정합니다.
• 구성 방식:
  • 매퍼 파일의 <mapper> 태그에서 namespace는 packagename.InterfaceName 형식으로 정의되며, SQL ID는 인터페이스 메서드 이름과 일치하게 설정합니다.
  • 예를 들어, com.ssafy.dao.UserMapper가 네임스페이스, search가 SQL ID로 지정되며, search 메서드가 XML의 <select id="search">와 자동 연결됩니다.
• 장점:
  • 이를 통해 Mapper Interface와 매핑 파일이 정확하게 매핑되며, SQL 호출이 직관적으로 이루어집니다.

---

5. 매핑과 메서드 이름의 연결

• 설명:
  • Mapper Interface와 매핑 파일을 통해, 인터페이스 메서드와 SQL ID가 1:1로 연결되어 SQL과 Java 메서드가 자동 매핑됩니다.
• 작동 방식:
  • 인터페이스의 메서드 이름과 매핑 파일의 SQL ID가 일치할 경우, MyBatis는 이 둘을 자동으로 연결하여, 메서드 호출만으로 해당 SQL 쿼리를 실행할 수 있게 합니다.
• 장점:
  • 코드를 간결하게 유지하면서 SQL 쿼리를 안전하게 호출할 수 있어 코드 유지보수성이 높아집니다.

---

✨ 이 구조의 장점

1. 타입 안전성:

   • 문자열을 사용하지 않으므로, 컴파일 단계에서 매개변수와 반환 타입이 맞지 않는 오류를 사전에 잡아낼 수 있습니다. 이를 통해 런타임 오류 발생 가능성이 줄어듭니다.

2. IDE 코드 지원:

   • Mapper Interface를 사용하면 IDE에서 자동완성 기능과 코드 지원을 받을 수 있어, 메서드 이름이나 매개변수 타입 실수를 줄일 수 있습니다. 또한, 메서드를 클릭하여 SQL 쿼리로 쉽게 이동할 수 있어 개발 생산성이 크게 향상됩니다.

3. 간결한 코드:

   • SQL 호출 시 직접 문자열을 입력하지 않으므로 코드가 간단하고 직관적입니다. 인터페이스 메서드를 통해 직접 SQL을 실행하므로, 유지보수가 용이하고 SQL 호출이 직관적입니다.

---

🌐 MyBatis와 Spring의 연동: 구조와 설정 방법

MyBatis를 Spring과 함께 사용하면 트랜잭션 관리, DI(의존성 주입) 등을 통해 개발 편의성과 안정성을 더욱 높일 수 있습니다. 아래에서 MyBatis를 단독으로 사용할 때와 Spring과 함께 사용할 때의 차이점, 그리고 Spring과의 연동을 위해 필요한 설정과 의존성 추가 방법을 상세히 설명드리겠습니다.

---

📌 MyBatis와 Spring 연동의 주요 개념

1. MyBatis를 Standalone(단독)으로 사용하는 경우

• 설명:
  • MyBatis를 Standalone(단독)으로 사용하는 경우, MyBatis의 SqlSessionFactory 객체를 직접 생성하고 이를 통해 SQL 쿼리를 실행합니다.
  • 이 방식은 Spring 없이 MyBatis만을 사용해 데이터베이스와 상호작용하는 방법입니다.
• 특징:
  • SqlSessionFactory를 직접 생성하고 관리해야 하므로 설정이 다소 복잡할 수 있습니다.
  • 트랜잭션 관리나 의존성 주입 기능이 제공되지 않아, 복잡한 데이터베이스 작업에서 추가적인 코드가 필요할 수 있습니다.

---

2. Spring과 연동하여 사용하는 경우

• 설명:
  • Spring과 연동하면 MyBatis 관련 객체들을 Spring 컨테이너에 Bean으로 등록하여 관리할 수 있습니다. 이때 Spring의 의존성 주입(Dependency Injection) 기능을 통해 MyBatis 객체들을 자동으로 주입받을 수 있습니다.
• 특징:
  • Spring의 DI(의존성 주입)를 통해 MyBatis의 SqlSessionFactory나 SqlSessionTemplate 같은 객체들을 직접 생성하지 않고, Spring 컨테이너가 관리하는 방식으로 사용할 수 있습니다.
  • 개발자가 직접 MyBatis 객체를 생성할 필요가 없으며, Spring에서 제공하는 빈 설정을 통해 필요한 객체를 자동으로 주입받을 수 있어 코드가 더욱 간결해집니다.

---

3. Spring에서 제공하는 트랜잭션 관리 기능

• 설명:
  • Spring은 트랜잭션 관리 기능을 기본 제공하며, MyBatis와 연동하면 Spring의 트랜잭션 관리 기능을 통해 트랜잭션을 자동 관리할 수 있습니다.
• 특징:
  • Spring의 선언적 트랜잭션 관리 기능을 활용하여 트랜잭션을 안전하게 처리할 수 있습니다.
  • 복잡한 트랜잭션 처리 로직을 직접 구현할 필요 없이, Spring이 트랜잭션 범위 내의 데이터베이스 작업을 자동으로 관리합니다.
  • 예를 들어, 여러 SQL 쿼리가 포함된 작업 중 하나라도 오류가 발생하면 자동으로 롤백됩니다. 이를 통해 데이터 일관성을 쉽게 유지할 수 있습니다.

---

4. Spring 연동을 위해 필요한 MyBatis 라이브러리

• 설명:
  • MyBatis를 Spring과 함께 사용하려면 MyBatis의 Spring 연동 라이브러리가 필요합니다.
  • 이를 위해 Maven 또는 Gradle과 같은 빌드 도구에서 mybatis와 mybatis-spring 라이브러리를 추가해야 합니다.
• 필수 의존성:
  • mybatis 라이브러리: MyBatis의 핵심 기능을 사용하기 위한 라이브러리입니다.
  • mybatis-spring 라이브러리: MyBatis와 Spring을 연동하기 위한 라이브러리로, Spring의 DI 및 트랜잭션 관리 기능을 활용할 수 있도록 지원합니다.

---

🛠️ 의존성 설정 예시 (Maven)

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>${org.mybatis-version}</version>
</dependency>

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>${org.mybatis-spring-version}</version>
</dependency>

• 설명:
  • 위 설정은 Maven에서 MyBatis와 Spring을 연동하기 위해 필요한 의존성입니다.
  • mybatis는 MyBatis 자체를 위한 라이브러리이며, mybatis-spring은 Spring 연동을 위해 필요한 라이브러리입니다.
  • 각 라이브러리의 버전은 프로젝트에 맞는 최신 버전을 사용할 수 있습니다.

---

🌐 MyBatis와 Spring 연동: DataSource 설정과 트랜잭션 관리

MyBatis와 Spring을 연동하여 데이터베이스와의 연결과 트랜잭션 처리를 효율적으로 관리하는 방법을 다룬 내용입니다. Spring을 통해 데이터베이스 연결 설정(DataSource)을 관리하고, 이를 기반으로 안전한 트랜잭션 처리를 Spring이 자동으로 처리할 수 있습니다. 아래에서 각 항목을 상세히 설명하겠습니다. 😊

---

📌 DataSource 설정 개요

1. Spring에서 DataSource 관리

• 설명:
  • Spring을 사용하는 경우, 데이터베이스 연결 정보(예: URL, 사용자명, 비밀번호 등)를 Spring의 설정 파일에서 관리하게 되며, 이를 통해 MyBatis 설정 파일에서 일부 설정을 생략할 수 있습니다.
  • Spring이 DataSource를 빈(Bean)으로 관리하므로, 애플리케이션은 Spring 컨테이너에서 이 빈을 주입받아 사용할 수 있습니다.
• 장점:
  • DataSource 설정이 Spring 컨텍스트로 관리되기 때문에 애플리케이션 전반에서 통합된 데이터베이스 접근 방식을 유지할 수 있으며, 코드의 일관성이 높아집니다.

---

2. Spring 환경 설정 파일에서 DataSource 설정

• 설명:

  • 일반적으로 application-context.xml과 같은 Spring 설정 파일에서 DataSource를 설정합니다. 여기서 데이터베이스 연결에 필요한 정보(예: URL, 드라이버 클래스, 사용자명, 비밀번호)를 지정합니다.
  • 이 설정 파일은 데이터베이스 연결 구성을 관리하는 주요 파일로, Spring 컨테이너가 DataSource를 관리할 수 있도록 합니다.

• 구성 요소:

  • driverClass: 데이터베이스 드라이버 클래스 이름
  • url: 데이터베이스 URL
  • username과 password: 데이터베이스 접근을 위한 사용자명과 비밀번호

• 예시 코드:

  <bean id="ds" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
      <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssafyweb?serverTimezone=UTC&amp;useUnicode=yes&amp;characterEncoding=UTF-8"/>
      <property name="username" value="ssafy"/>
      <property name="password" value="ssafy"/>
  </bean>

• 설명:

  • id="ds": DataSource를 ds라는 이름으로 등록하여, 필요 시 이 이름으로 참조할 수 있습니다.
  • driverClass와 url: MySQL 드라이버와 데이터베이스 주소를 지정하여 연결 경로를 설정합니다.
  • username과 password: 데이터베이스 접근에 필요한 인증 정보를 설정하여 보안성을 유지합니다.

---

3. DataSource는 데이터베이스 연결 정보를 가진 객체

• 설명:
  • DataSource는 데이터베이스와의 연결을 관리하는 객체로, 애플리케이션이 필요할 때마다 새로운 연결을 제공합니다.
  • 데이터베이스 연결 URL, 드라이버 클래스, 사용자명, 비밀번호 등의 정보를 포함하며, Spring이 이 객체를 관리함으로써 데이터베이스와의 연결을 통합적으로 관리할 수 있습니다.
• 장점:
  • 데이터베이스와의 연결을 효율적으로 관리하여 성능을 최적화할 수 있으며, 트랜잭션 처리 시 일관된 연결 관리를 통해 안정성을 높입니다.

---

4. 트랜잭션 관리

• 설명:
  • MyBatis와 Spring이 연동되면, 트랜잭션 처리 역시 Spring이 자동으로 관리할 수 있습니다.
  • Spring의 트랜잭션 관리 기능을 통해 트랜잭션의 시작, 커밋, 롤백과 같은 작업이 자동화되어 데이터베이스 작업이 더욱 안전하게 수행됩니다.
• 장점:
  • Spring의 선언적 트랜잭션 관리 기능을 사용하면, 여러 데이터베이스 작업이 하나의 트랜잭션으로 처리되어 중간 오류 발생 시 자동으로 롤백되며 데이터의 무결성을 보장할 수 있습니다.

---

🛠️ Connection Pool 설정

• 데이터베이스와의 성능을 향상시키기 위해, JNDI(Java Naming and Directory Interface)를 사용하여 Connection Pool을 설정할 수도 있습니다. Connection Pool을 사용하면 필요한 연결을 미리 만들어두고 필요할 때 재사용할 수 있어 성능이 최적화됩니다.

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="java:comp/env/jdbc/ssafy"/>
</bean>

• 설명:
  • id="dataSource": JNDI를 통해 제공되는 Connection Pool을 관리하는 DataSource 객체입니다.
  • jndiName: 애플리케이션 서버에서 설정한 Connection Pool의 이름입니다. 이 이름을 통해 Connection Pool을 참조할 수 있습니다.
• 장점:
  • Connection Pool을 사용하면 성능이 개선되고, 애플리케이션의 연결 관리가 더욱 효율적이므로 대규모 트랜잭션에서도 안정적인 동작을 보장할 수 있습니다.

---

💼 JNDI (Java Naming and Directory Interface): 이름으로 리소스를 찾고 관리하기! 🌐

JNDI는 Java 애플리케이션이 네트워크상의 다양한 리소스에 이름만으로 접근할 수 있도록 도와주는 강력한 API입니다. 이를 통해 데이터베이스 연결, 메일 서버 또는 디렉터리 서비스 등 다양한 외부 자원을 이름을 통해 쉽게 사용할 수 있습니다. 📌 아래에서 JNDI의 개념과 그 활용을 자세히 알아보겠습니다!

---

📚 JNDI의 개념

• JNDI는 이름과 객체 간의 매핑을 제공하는 디렉터리 및 네이밍 서비스를 추상화한 API입니다.
• 이를 통해 특정 객체가 어디에 위치해 있는지 몰라도 이름을 통해 객체를 찾고 사용할 수 있습니다.
• 객체의 위치가 아닌 이름을 사용하여 검색하므로, 개발자가 쉽게 리소스에 접근하고 관리할 수 있습니다.

---

🔍 JNDI의 주요 용도

1. 데이터베이스 연결 관리 🗄️:

   • 연결 풀(Connection Pool)을 설정하여 애플리케이션이 이를 참조하게 합니다.
   • 애플리케이션 서버(예: Tomcat, WebLogic)가 JNDI를 통해 미리 설정된 데이터베이스 연결을 제공하면, 애플리케이션은 이름을 통해 간편하게 데이터베이스에 접근할 수 있습니다.

2. 원격 객체 접근 🌐:

   • 분산 시스템에서 EJB (Enterprise Java Beans)와 같은 원격 객체를 이름만으로 찾아 사용할 수 있습니다.
   • 예를 들어, RMI(Remote Method Invocation) 객체를 참조할 때도 JNDI를 활용해 객체의 위치를 몰라도 사용할 수 있습니다.

3. 메일 서버 연결 📧:

   • JavaMail API와 결합하여 메일 서버와 상호작용합니다.
   • 메일 서버 정보가 JNDI에 등록되어 있으면, 이름으로 메일 서버에 쉽게 접근할 수 있어 메일 전송, 수신 작업이 간편해집니다.

4. 디렉터리 서비스 연동 🗂️:

   • JNDI는 LDAP(디렉터리 서비스)와 연동하여 사용자 정보, 인증 데이터를 조회할 수 있습니다.
   • LDAP 같은 디렉터리 서비스는 대규모 조직에서 사용자와 관련된 정보를 관리할 때 주로 사용됩니다.

---

⚙️ JNDI의 동작 원리

1. 네이밍 서비스 연결 🔗:

   • JNDI는 네이밍 서비스(예: 데이터베이스, EJB, LDAP)에 연결하여 필요한 리소스를 검색할 수 있도록 합니다.

2. 이름으로 객체 검색 🔍:

   • Context.lookup("java:comp/env/jdbc/myDB")처럼 이름을 통해 원하는 리소스를 검색하고, 해당 객체를 반환받습니다.

3. 네임스페이스 관리 🗂️:

   • JNDI는 계층적 네임스페이스 구조로, 디렉터리처럼 트리 형태로 리소스를 관리합니다.
   • 예: java:comp/env은 Java 컴포넌트 환경을 나타내며, 그 아래에 jdbc/myDB라는 데이터베이스 연결이 포함됩니다.

4. 리소스 바인딩 및 해제 🎛️:

   • 바인딩(binding)을 통해 이름과 객체 간의 연결이 설정됩니다.
   • 반대로, 해제(unbinding)는 이름과 객체 간의 연결을 끊습니다.

---

💡 JNDI를 사용한 데이터베이스 연결 예시

1. Tomcat에서 JNDI DataSource 설정 예시

Tomcat의 context.xml 파일에서 JNDI DataSource를 설정하여 데이터베이스 연결 풀을 관리합니다.

<Resource name="jdbc/myDB"
          auth="Container"
          type="javax.sql.DataSource"
          maxTotal="100"
          maxIdle="30"
          maxWaitMillis="10000"
          username="dbuser"
          password="dbpassword"
          driverClassName="com.mysql.cj.jdbc.Driver"
          url="jdbc:mysql://localhost:3306/mydatabase"/>

• name: JNDI에서 DataSource를 참조할 이름입니다.
• type: javax.sql.DataSource로 지정하여 데이터베이스 연결 풀을 설정합니다.
• url: 데이터베이스 연결 URL.
• username과 password: 데이터베이스 인증 정보입니다.

2. Java 코드에서 JNDI DataSource 참조 예시

Java 코드에서 DataSource를 참조하는 방식은 아래와 같습니다.

InitialContext ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/myDB");
Connection conn = ds.getConnection();

• InitialContext: JNDI 네이밍 서비스의 진입점으로, 네이밍 및 디렉터리 서비스와 상호작용합니다.
• lookup: 네임스페이스에서 jdbc/myDB를 검색하여 연결 풀을 가져옵니다.
• Connection: DataSource를 통해 얻은 데이터베이스 연결 객체입니다.

---

🌟 JNDI의 장단점

👍 장점

1. 유연한 리소스 관리:
   • 리소스의 위치가 바뀌더라도 이름만으로 접근할 수 있으므로 애플리케이션을 수정할 필요가 없습니다.
2. 애플리케이션 서버와의 통합:
   • JNDI는 애플리케이션 서버와 쉽게 통합되어 설정을 관리할 수 있으며, 설정된 연결 풀을 재사용하여 효율성을 높입니다.
3. 분산 시스템 지원:
   • 원격 객체와 분산 리소스를 쉽게 관리할 수 있으며, 네트워크 리소스를 한곳에서 관리하기에 좋습니다.

👎 단점

1. 초기 설정의 복잡성:
   • 강력한 기능을 제공하는 만큼 설정이 복잡할 수 있으며, 이해하고 설정하는 데 다소 시간이 걸립니다.
2. 애플리케이션 서버 의존성:
   • 주로 애플리케이션 서버 환경에서 사용되므로, 서버에 종속적인 설정이 될 수 있습니다. 특정 환경에서만 작동할 가능성도 있습니다.

---

💼 MyBatis와 Spring의 트랜잭션 관리 연동 🔄

Spring은 강력한 트랜잭션 관리 기능을 제공하며, 이를 MyBatis와 함께 사용하면 데이터베이스 작업을 더욱 안전하게 처리할 수 있습니다. 이 구조에서는 트랜잭션 관리자가 어떻게 설정되고, 어노테이션 기반 트랜잭션 처리가 어떻게 작동하는지 설명하고 있습니다.

---

🛠️ 트랜잭션 관리자 설정

1. 트랜잭션 관리자란?

   • 트랜잭션 관리자(transactionManager)는 데이터베이스 작업을 트랜잭션 단위로 묶어 관리하는 객체입니다. Spring에서 DataSourceTransactionManager를 사용하여 MyBatis의 데이터베이스 트랜잭션을 제어합니다.
   • 이 관리자는 트랜잭션의 시작, 커밋, 롤백을 담당하며, Spring과 MyBatis가 연동되어도 이러한 작업을 자동으로 수행합니다.

2. 트랜잭션 관리자의 빈 설정

   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource" />
   </bean>

   • id="transactionManager": 이 빈은 transactionManager라는 이름으로 관리됩니다.
   • class: DataSourceTransactionManager 클래스는 JDBC 기반의 트랜잭션을 관리하는 Spring 제공 객체입니다.
   • dataSource: 이 프로퍼티는 데이터베이스와의 연결을 위한 DataSource를 참조합니다. dataSource는 트랜잭션 관리에 필요한 데이터베이스 연결 정보를 제공합니다.

3. tx:annotation-driven 요소

   • tx:annotation-driven 설정을 추가하여 어노테이션 방식으로 트랜잭션을 선언할 수 있습니다. 이를 통해 코드 내에서 메서드에 @Transactional 어노테이션을 달아 트랜잭션 처리를 쉽게 제어할 수 있습니다.

4. 어노테이션 기반 트랜잭션 설정

   <tx:annotation-driven transaction-manager="transactionManager" />

   • tx:annotation-driven: 이 설정을 통해 @Transactional 어노테이션으로 선언된 메서드나 클래스가 트랜잭션 관리를 받을 수 있게 합니다.
   • transaction-manager: transactionManager를 트랜잭션 관리자로 지정합니다.

---

🖋️ @Transactional 어노테이션 사용

• @Transactional: 이 어노테이션을 사용하면, 메서드 또는 클래스 단위로 트랜잭션을 선언적으로 관리할 수 있습니다. AOP (Aspect-Oriented Programming)를 통해 트랜잭션이 적용되며, Spring이 자동으로 트랜잭션의 시작과 종료를 처리합니다.

• AOP를 통한 트랜잭션 처리: @Transactional이 적용된 메서드에서 작업이 성공하면 커밋하고, 예외가 발생하면 롤백합니다. 이를 통해 데이터의 무결성과 일관성을 유지합니다.

@Transactional
public void saveData() {
    // 이 메서드에는 트랜잭션이 적용됩니다.
    // 성공 시 커밋, 예외 발생 시 롤백됩니다.
}

⚡ 주요 개념 요약

• transactionManager 설정: JDBC 기반 트랜잭션 관리에는 Spring의 DataSourceTransactionManager를 사용하여 설정합니다.
• tx:annotation-driven 설정: 어노테이션 기반 트랜잭션 적용을 가능하게 합니다.
• @Transactional 어노테이션: 트랜잭션이 필요한 메서드나 클래스에 적용하며, Spring의 AOP로 트랜잭션이 관리됩니다.

---

🌟 이점

• 안정적인 트랜잭션 관리: 트랜잭션 관리자와 @Transactional을 통해 데이터베이스 작업이 안전하게 처리됩니다.
• 트랜잭션 범위의 일관성: 메서드 단위로 트랜잭션 범위를 지정하여 작업이 일관되게 처리됩니다.
• 에러 처리의 용이성: 오류 발생 시 트랜잭션을 쉽게 롤백할 수 있어 데이터 무결성이 보장됩니다.

이 구조는 Spring과 MyBatis가 함께 작동할 때 안정적이고 효율적인 트랜잭션 관리를 제공하며, 데이터 작업이 안전하게 수행되도록 도와줍니다. 🛡️

---

💡 MyBatis와 Spring 연동 시 SqlSessionFactoryBean 설정 💡

이 설정은 MyBatis와 Spring을 연동하기 위한 핵심 구성 요소인 SqlSessionFactoryBean을 설정하는 방법을 설명합니다. SqlSessionFactoryBean은 MyBatis에서 SQL 쿼리와 트랜잭션을 실행하는 SqlSessionFactory 객체를 Spring의 빈(Bean)으로 관리할 수 있도록 해줍니다.

---

🔍 SqlSessionFactoryBean 설정 항목

1. SqlSessionFactory 역할

   • MyBatis 애플리케이션의 모든 SQL 쿼리와 트랜잭션 작업을 담당하는 핵심 객체가 SqlSessionFactory입니다.
   • Spring 환경에서는 SqlSessionFactoryBean을 통해 이 객체를 생성하여 관리합니다. 이를 통해 데이터베이스 연결을 비롯한 다양한 작업을 제어할 수 있습니다.

2. Spring Bean으로 SqlSessionFactoryBean 등록

   • Spring 애플리케이션에서 SqlSessionFactoryBean을 등록하면, MyBatis는 Spring의 DataSource와 설정 파일을 통해 SQL 세션을 생성하고 관리합니다.
   • 데이터 소스와 MyBatis 설정 파일 정보를 함께 지정하여 MyBatis가 데이터베이스와의 상호작용을 원활하게 할 수 있도록 설정합니다.

---

📄 XML 설정 코드 설명

<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:mybatis-config.xml" />
    <property name="mapperLocations">
        <list>
            <value>classpath:mapper/member.xml</value>
            <value>classpath:mapper/board.xml</value>
        </list>
    </property>
</bean>

• id="sqlSessionFactoryBean": sqlSessionFactoryBean이라는 이름으로 이 Bean이 Spring 컨테이너에 등록됩니다.
• class="org.mybatis.spring.SqlSessionFactoryBean": 이 클래스를 통해 Spring에서 MyBatis와 연동된 SqlSessionFactoryBean을 사용합니다.

---

📝 속성(Property) 설정 상세 설명

• DataSource 설정

  <property name="dataSource" ref="dataSource" />

  • dataSource 속성은 MyBatis가 데이터베이스와의 연결을 관리하는 DataSource 객체를 참조합니다. 여기서 dataSource는 별도로 정의된 DataSource Bean을 참조합니다.
  • 이를 통해 SqlSessionFactory가 SQL 세션을 생성할 때 데이터베이스 연결 정보를 사용할 수 있습니다.

• MyBatis 설정 파일 (configLocation)

  <property name="configLocation" value="classpath:mybatis-config.xml" />

  • configLocation은 MyBatis의 설정 파일 경로를 지정하는 속성입니다. 예를 들어 mybatis-config.xml 파일에는 캐시, 매퍼 설정, 트랜잭션 설정 등이 포함됩니다.
  • classpath: 접두어는 설정 파일이 클래스패스 내에 위치함을 나타내며, MyBatis는 이 경로를 따라 필요한 설정 정보를 로드합니다.

• Mapper 파일 위치 (mapperLocations)

  <property name="mapperLocations">
      <list>
          <value>classpath:mapper/member.xml</value>
          <value>classpath:mapper/board.xml</value>
      </list>
  </property>

  • mapperLocations는 MyBatis의 SQL 쿼리와 Java 객체 간의 매핑을 정의한 매퍼 파일들의 경로를 지정하는 속성입니다.
  • <list> 안에 여러 개의 매퍼 파일을 추가할 수 있으며, 예시에서는 member.xml과 board.xml 두 개의 매퍼 파일을 지정했습니다.
  • 이 XML 파일들은 SQL 쿼리와 Java 객체 간의 매핑 규칙을 정의하여 데이터베이스와의 상호작용을 돕습니다.

---

🎯 MyBatis와 Spring의 통합: SqlSessionFactoryBean 설정

이 설정은 MyBatis와 Spring이 통합되어 SQL 세션을 생성하고 관리하기 위한 SqlSessionFactoryBean 구성 요소와 역할을 설명합니다. SqlSessionFactoryBean은 Spring에서 MyBatis의 핵심 SQL 작업을 Bean으로 관리할 수 있게 해주는 클래스입니다.

---

🛠️ SqlSessionFactoryBean 설정 요소 설명

1. SqlSessionFactoryBean 설정

   • SqlSessionFactory는 MyBatis의 핵심 역할을 담당하며, SQL 쿼리 실행과 트랜잭션 관리를 수행합니다. Spring 환경에서 이 객체를 관리하려면 SqlSessionFactoryBean을 Bean으로 등록합니다.
   • 이 설정을 통해 MyBatis와 Spring이 통합되고, SQL 작업을 위한 세션을 생성하여 효율적으로 관리할 수 있습니다.

2. 설정 XML 코드

   <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource" />
       <property name="typeAliasesPackage" value="com.ssafy.*.model" />
       <property name="mapperLocations" value="classpath:mapper/*.xml" />
   </bean>

---

🔍 각 속성별 역할 상세 설명

• DataSource 연결 설정

  <property name="dataSource" ref="dataSource" />

  • DataSource는 데이터베이스와의 연결을 관리하는 설정으로, MyBatis가 데이터베이스와 통신할 수 있게 합니다.
  • ref="dataSource"는 Spring 컨테이너에서 관리되는 DataSource Bean을 참조하여 MyBatis가 이를 통해 데이터베이스와의 연결을 수행하도록 합니다.

• TypeAlias 설정 (typeAliasesPackage)

  <property name="typeAliasesPackage" value="com.ssafy.*.model" />

  • typeAliasesPackage는 지정된 패키지 경로 내의 모든 Java 클래스에 대해 별칭(alias)을 설정합니다. 별칭을 통해 Java 클래스의 전체 경로를 사용하지 않고도 매퍼 파일에서 간단히 사용할 수 있습니다.
  • 예를 들어 com.ssafy.member.model.Member 클래스는 별칭 Member로 참조 가능하게 되어, MyBatis 매퍼 파일에서 더 간편하게 사용할 수 있습니다.

• Mapper XML 파일 설정 (mapperLocations)

  <property name="mapperLocations" value="classpath:mapper/*.xml" />

  • mapperLocations는 MyBatis의 매퍼 XML 파일 위치를 지정하여, MyBatis가 SQL 쿼리와 Java 객체 간의 매핑을 관리할 수 있도록 합니다.
  • classpath:mapper/*.xml은 mapper 폴더 내의 모든 XML 파일을 매퍼 파일로 지정하여 MyBatis에서 자동으로 인식하고 사용할 수 있게 합니다.

---

🎉 MyBatis와 Spring 연동: Mapper 인터페이스 등록 방법

이 설정은 MyBatis에서 SQL을 호출하는 Mapper 인터페이스를 Spring 애플리케이션에서 빈(Bean)으로 관리할 수 있도록 등록하는 방법을 설명합니다. 두 가지 방식이 있으며, 각각의 설정 방식과 장단점을 비교하여 설명드리겠습니다.

---

🛠️ Mapper 인터페이스 등록 방식

1️⃣ [방법 1] Mapper 인터페이스를 직접 등록

<bean id="boardMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.ssafy.board.model.mapper.BoardMapper"/>
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

• MapperFactoryBean: Spring에서 MyBatis의 Mapper 인터페이스를 직접 Bean으로 등록하는 클래스입니다.
• id="boardMapper": boardMapper라는 이름으로 Spring에서 관리되며, 애플리케이션에서 이 이름으로 Mapper 인터페이스를 참조합니다.
• property name="mapperInterface": BoardMapper라는 인터페이스를 등록하며, 이 Mapper는 MyBatis 매퍼 파일에서 정의된 SQL 쿼리와 연결됩니다.
• property name="sqlSessionFactory": sqlSessionFactory를 참조하여 SQL 쿼리 실행에 필요한 세션을 제공받습니다.

🔹 이 방식의 특징:

• 개별 등록이므로 특정 Mapper 인터페이스만 등록할 때 유용합니다.
• 모든 Mapper를 하나씩 수동 등록해야 하므로 다수의 Mapper를 관리할 때는 불편할 수 있습니다.
• 개별적인 제어가 필요한 경우에 적합합니다.

---

2️⃣ [방법 2] Mapper Scanner 사용

<mybatis-spring:scan base-package="com.ssafy.*.model.mapper"/>

• mybatis-spring:scan: MyBatis에서 제공하는 스캐너 태그로, 지정된 패키지에 속한 모든 Mapper 인터페이스를 자동으로 빈으로 등록하는 기능을 합니다.
• base-package="com.ssafy.*.model.mapper": com.ssafy.*.model.mapper 경로 내의 모든 Mapper 인터페이스가 자동으로 등록됩니다.

🔹 이 방식의 특징:

• 여러 Mapper 인터페이스를 한 번의 설정으로 일괄 등록할 수 있습니다.
• 많은 Mapper를 자동으로 관리할 수 있어 설정이 간편하고 편리합니다.
• 특정 패키지 내의 모든 Mapper를 빈으로 등록할 때 적합합니다.

---

📝 두 방식의 차이점 정리

특성	직접 등록 (방법 1)	Mapper Scanner 사용 (방법 2)
사용 용도	개별적인 Mapper 등록	특정 패키지 내의 모든 Mapper 자동 등록
장점	세밀한 제어 가능	많은 Mapper를 간편하게 일괄 등록 가능
단점	여러 개를 등록할 때 불편함	패키지 내 모든 Mapper가 등록되므로 개별 조정 어려움
설정 편의성	수동으로 하나씩 등록	설정 간단, 패키지 경로만 지정

---

✨ MyBatis와 Spring 연동에서의 Service 클래스와 Mapper 인터페이스 상호작용

이 코드는 MyBatis와 Spring이 연동된 환경에서 Service 클래스와 Mapper 인터페이스가 어떻게 데이터베이스와 상호작용하며, 이를 통해 비즈니스 로직을 처리하는지를 보여줍니다. 다음은 각각의 요소에 대한 일반적인 설명입니다.

---

🔹 1. Service Class

Service 클래스는 애플리케이션에서 비즈니스 로직을 처리하는 계층입니다. Spring의 DI(의존성 주입)을 통해 Mapper 인터페이스와 연결되어 데이터베이스 작업을 수행할 수 있게 됩니다.

@Service
public class ExampleServiceImpl implements ExampleService {

    private final ExampleMapper exampleMapper;

    public ExampleServiceImpl(ExampleMapper exampleMapper) {
        this.exampleMapper = exampleMapper;
    }

    @Override
    @Transactional
    public void processEntity(EntityDto entityDto) throws Exception {
        System.out.println("처리 전: " + entityDto);
        exampleMapper.insertEntity(entityDto);
        System.out.println("처리 후: " + entityDto);

        List<FileInfoDto> fileInfos = entityDto.getFileInfos();
        if (fileInfos != null && !fileInfos.isEmpty()) {
            exampleMapper.insertFileInfos(fileInfos);
        }
    }
}

💡 주요 설명:

• @Service: Spring이 해당 클래스를 서비스 Bean으로 인식하여 등록합니다.
• private final ExampleMapper exampleMapper: MyBatis의 Mapper 인터페이스 ExampleMapper를 의존성 주입을 통해 연결합니다. final 키워드는 의존성이 반드시 초기화되어야 함을 보장합니다.
• 생성자 주입: 생성자를 통해 Mapper 인터페이스의 구현체가 주입됩니다.
• @Transactional: 이 메서드 내 모든 데이터베이스 작업이 하나의 트랜잭션으로 묶입니다. 성공 시 커밋되고, 예외 발생 시 롤백됩니다.
• 부가적 파일 정보 저장: entityDto에 포함된 파일 정보를 가져와, 만약 존재할 경우 별도의 테이블에 저장하기 위한 작업을 수행합니다.

---

🔹 2. Mapper Interface

Mapper 인터페이스는 MyBatis에서 데이터베이스와의 상호작용을 담당하며, SQL 쿼리와 Java 객체 간의 매핑을 설정합니다. 각 메서드는 데이터베이스 작업(삽입, 조회 등)을 정의하고 있으며, MyBatis는 XML이나 애노테이션을 통해 각 메서드에 해당하는 SQL을 매핑합니다.

@Mapper
public interface ExampleMapper {

    void insertEntity(EntityDto entityDto) throws SQLException;

    void insertFileInfos(List<FileInfoDto> fileInfos) throws SQLException;

    List<EntityDto> listEntities(Map<String, Object> params) throws SQLException;

    int getTotalCount(Map<String, Object> params) throws SQLException;

    EntityDto getEntityById(int id) throws SQLException;
}

💡 주요 설명:

• @Mapper: 해당 인터페이스가 MyBatis Mapper임을 나타내며, Spring에서 자동으로 Bean으로 등록됩니다.
• CRUD 메서드:
  • insertEntity: 단일 엔티티 정보를 데이터베이스에 삽입합니다.
  • insertFileInfos: 여러 파일 정보를 리스트 형태로 전달받아 삽입합니다.
  • listEntities: 조건에 따라 여러 엔티티를 조회합니다.
  • getTotalCount: 특정 조건에 맞는 엔티티 개수를 조회하여 반환합니다.
  • getEntityById: 주어진 ID에 해당하는 엔티티를 단일 조회합니다.