[Spring Boot] (3) MyBatis 3에서의 DB 설정

앞서 MyBatis의 프로퍼티를 셋팅할 때, MybatisProperties의 Configuration 정보를 SqlSessionFactory의 Configuration에 일일이 셋팅을 해주었었다.

MyBatis 2에서는 Configuration을 가져온다.

MyBatis 3에서는 CoreConfiguration이라는 것을 가져온다.

MyBatis 2에서는 getConfiguration() 메서드를 사용하면 Configuration을 가져왔었지만 MyBatis 3에서는 내부클래스인 CoreConfiguration을 가져온다.

 

 

내부를 보면 Configuration의 설정과 같은 필드들이 있다. 여기서 눈여겨 봐야할 건 해당 클래스에 선언된 applyTo() 메서드이다.

 

 

해당 메서드를 보면 Configuration을 파라미터로 받아, CoreConfiguration의 값들을 셋팅해주는 것을 볼 수 있다.

MyBatis 2에서는 해당 셋팅 부분을 일일이 작성했었어야하지만 MyBatis 3에서는 그러한 수고스러움을 덜 수 있도록 메서드가 만들어져 있다.

 

 

그럼 이것을 적용시켜보도록 하자.

 

DBConfig.java

package com.springboot3.db.config;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import jakarta.persistence.EntityManagerFactory;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;

import javax.sql.DataSource;
import java.util.Map;

@Configuration
public class DBConfig {

  @Autowired
  private HibernateProperties hibernateProperties;

  @Autowired
  private JpaProperties jpaProperties;

  @Autowired
  private MybatisProperties mybatisProperties;

  protected DataSource setDataSource() {
    return DataSourceBuilder.create()
      .type(HikariDataSource.class)
      .build();
  }

  protected EntityManagerFactory setEntityManagerFactory(DataSource dataSource,
                                                         String entityPackagePath,
                                                         String persistUnitName) {
    JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    Map<String, Object> properties = hibernateProperties.determineHibernateProperties(
      jpaProperties.getProperties(), new HibernateSettings()
    );

    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setDataSource(dataSource);
    factory.setPackagesToScan(entityPackagePath);
    factory.setPersistenceUnitName(persistUnitName);
    factory.setJpaPropertyMap(properties);
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.afterPropertiesSet();

    return factory.getObject();
  }

  protected SqlSessionFactory makeSqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
    sessionFactoryBean.setDataSource(dataSource);
    sessionFactoryBean.setVfs(SpringBootVFS.class);
    sessionFactoryBean.setMapperLocations(mybatisProperties.resolveMapperLocations());
    sessionFactoryBean.setTypeAliasesPackage(mybatisProperties.getTypeAliasesPackage());

    return sessionFactoryBean.getObject();
  }

  protected void setMybatisProperties(SqlSessionFactory sqlSessionFactory) {
  	// SqlSessionFactory에서 Configuration 정보를 가져와 넣어준다.
    mybatisProperties.getConfiguration().applyTo(sqlSessionFactory.getConfiguration());
  }
}

 

FirstDBConfig.java

package com.springboot3.db.config;

import jakarta.persistence.EntityManagerFactory;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@EnableJpaRepositories(
  basePackages = "com.springboot3.db.repository.first",
  entityManagerFactoryRef = "firstEntityManagerFactory",
  transactionManagerRef = "firstTransactionManager"
)
@MapperScan(value = "com.springboot3.db.mapper.first", sqlSessionFactoryRef = "firstSessionFactory")
public class FirstDBConfig extends DBConfig {

  private final String FIRST_DATA_SOURCE = "firstDataSource";

  private final String FIRST_MANAGER_FACTORY = "firstEntityManagerFactory";

  private final String FIRST_TRANSACTION_MANAGER = "firstTransactionManager";

  private final String FIRST_SESSION_FACTORY = "firstSessionFactory";

  private final String FIRST_SESSION_TEMPLATE = "firstSessionTemplate";

  private final String FIRST_ENTITY_PACKAGE = "com.springboot3.db.entity.first";

  private final String FIRST_PERSIST_UNIT_NAME = "firstEntityManager";

  @ConfigurationProperties(prefix = "spring.first-db.datasource")
  @Bean(name = FIRST_DATA_SOURCE)
  @Primary
  public DataSource firstDataSource() {

    return super.setDataSource();
  }

  @Bean(name = FIRST_MANAGER_FACTORY)
  @Primary
  public EntityManagerFactory entityManagerFactory(@Qualifier(FIRST_DATA_SOURCE) DataSource dataSource) {

    return super.setEntityManagerFactory(dataSource, FIRST_ENTITY_PACKAGE, FIRST_PERSIST_UNIT_NAME);
  }

  @Bean(name = FIRST_TRANSACTION_MANAGER)
  @Primary
  public PlatformTransactionManager transactionManager(@Qualifier(FIRST_MANAGER_FACTORY) EntityManagerFactory entityManagerFactory) {

    return new JpaTransactionManager(entityManagerFactory);
  }

  @Bean(name = FIRST_SESSION_FACTORY)
  @Primary
  public SqlSessionFactory sqlSessionFactory(@Qualifier(FIRST_DATA_SOURCE) DataSource dataSource) throws Exception {

    return super.makeSqlSessionFactory(dataSource);
  }

  @Bean(name = FIRST_SESSION_TEMPLATE)
  @Primary
  public SqlSessionTemplate firstSqlSessionTemplate(@Qualifier(FIRST_SESSION_FACTORY) SqlSessionFactory sqlSessionFactory) {
    super.setMybatisProperties(sqlSessionFactory);

    return new SqlSessionTemplate(sqlSessionFactory);
  }
}

SqlSessionTemplate을 생성하는 부분에서 SqlSessionFactory를 인자로 받기 때문에 여기서 Configuration 정보를 가져와 셋팅해주면 된다.

 

config 정보를 삭제하고 mapper 정보만 남겨놓았다.

 

config-location 정보를 삭제하고 모든 설정을 yml로 이전했다.

 

DBConfig에도 confLocation 정보를 셋팅할 필요 없기 때문에 삭제했다.

 

 

FIRST DB JPA : 121 : Pikachu
FIRST DB JPA : 122 : Bulbasaur
FIRST DB JPA : 123 : Charmander
FIRST DB JPA : 124 : Squirtle
FIRST DB JPA : 125 : Butterfree
FIRST DB JPA : 126 : Rattata
FIRST DB JPA : 127 : Clefairy
FIRST DB JPA : 128 : Arbok
FIRST DB JPA : 129 : Diglett
FIRST DB JPA : 130 : Kadabra
FIRST DB MyBatis : 121 : Pikachu
FIRST DB MyBatis : 122 : Bulbasaur
FIRST DB MyBatis : 123 : Charmander
FIRST DB MyBatis : 124 : Squirtle
FIRST DB MyBatis : 125 : Butterfree
FIRST DB MyBatis : 126 : Rattata
FIRST DB MyBatis : 127 : Clefairy
FIRST DB MyBatis : 128 : Arbok
FIRST DB MyBatis : 129 : Diglett
FIRST DB MyBatis : 130 : Kadabra

SECOND DB JPA : 10000, 99
SECOND DB JPA : 20000, 98
SECOND DB JPA : 20000, 197
SECOND DB JPA : 40000, 296
SECOND DB MyBatis : 10000, 99
SECOND DB MyBatis : 20000, 98
SECOND DB MyBatis : 20000, 197
SECOND DB MyBatis : 40000, 296

테스트 결과 정상적으로 작동한다.

 

이것으로 처음에 내가 원하던대로 MyBatis의 설정을 application.yml에 한 번에 셋팅할 수 있게 되었다. 😆