spring:
  datasource:
    driver-class-name: {DB Driver 패키지}
    url: {DB IP주소, 포트 및 스키마 명}
    username: {DB 계정}
    password: {비밀번호}
  jpa:
    show-sql: true
    properties:
      hibernate:
        dialects: org.hibernate.dialect.MySQL57Dialect
        format_sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: create-drop

# 원하는 양식 사용.
datasource:
  master:
    name: master
    url: {DB IP주소, 포트 및 스키마 명} # jdbc:mysql://{DB 주소}{스키마 명}?serverTimezone=UTC&characterEncoding=UTF-8
    username: {DB 계정}
    password: {비밀번호}
  slave:
    slave1:
      name: slave1
      url: {DB IP주소, 포트 및 스키마 명}
      username: {DB 계정}
      password: {비밀번호}
    slave2:
      name: slave2
      url: {DB IP주소, 포트 및 스키마 명}
      username: {DB 계정}
      password: {비밀번호}

// 빈으로 등록된 Configuration에서 @EnableConfigurationProperties 혹은 @ConfigurationPropertiesScan를 통해 스캔해야 한다.
@ConfigurationProperties(prefix = "datasource") // 1
public class DataSourceProperties {

    private Map<String, DatasourceNode> slave = new HashMap<>();
    private DatasourceNode master;

    // Getter, Setter

    // DatasourceNode (요소) - Master DB 혹은 Slave DB의 정보를 담고 있는 객체
    public static class DatasourceNode {
        private String name;
        private String url;
        private String username;
        private String password;

        // Getter, Setter
    }
}

@DisplayName("Profile에 명시된 DataSource 정보를 잘 가져오는지 확인하는 테스트")
@SpringBootTest(webEnvironment = WebEnvironment.NONE)
@EnableConfigurationProperties(DataSourceProperties.class) // 2
class DataSourcePropertiesTest {

    @Autowired
    private DataSourceProperties dataSourceProperties;

    @DisplayName("Profile에 정의된 Master의 값을 바인딩한다.")
    @Test
    void bindDataSource_Master() {
        // given
        DatasourceNode expected = new DatasourceNode();
        expected.setName("master");
        expected.setUrl("{DB IP주소, 포트 및 스키마 명}");
        expected.setUsername("{DB 계정}");
        expected.setPassword("{비밀번호}");

        // when
        DatasourceNode master = dataSourceProperties.getMaster();

        // then
        assertThat(master)
            .usingRecursiveComparison()
            .isEqualTo(expected);
    }

    @DisplayName("Profile에 정의된 Slave의 값을 바인딩한다.")
    @Test
    void bindDataSource_Slaves() {
        // given
        DatasourceNode expected1 = new DatasourceNode();
        expected1.setName("slave1");
        expected1.setUrl("{DB IP주소, 포트 및 스키마 명}");
        expected1.setUsername("{DB 계정}");
        expected1.setPassword("{비밀번호}");

        DatasourceNode expected2 = new DatasourceNode();
        expected2.setName("slave2");
        expected2.setUrl("{DB IP주소, 포트 및 스키마 명}");
        expected2.setUsername("{DB 계정}");
        expected2.setPassword("{비밀번호}");

        // when
        Map<String, DatasourceNode> slaves = dataSourceProperties.getSlave();

        // then
        assertThat(slaves.get(expected1.getName()))
            .usingRecursiveComparison()
            .isEqualTo(expected1);
        assertThat(slaves.get(expected2.getName()))
            .usingRecursiveComparison()
            .isEqualTo(expected2);
    }
}

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

	@Nullable
	private Map<Object, Object> targetDataSources; // 여러 DataSource 정의

	@Nullable
	private Object defaultTargetDataSource; // 기본 DataSource

    ...

public class ReplicationRoutingDataSource extends AbstractRoutingDataSource {

    private static final Logger LOGGER = LoggerFactory.getLogger(ReplicationRoutingDataSource.class);
    private static final String MASTER_NAME = "master";

    private List<String> slaveNames = new ArrayList<>();
    private int counter = 0;

    // Routing에 사용될 Datasource 주입하는 Setter
    @Override
    public void setTargetDataSources(Map<Object, Object> targetDataSources) {
        super.setTargetDataSources(targetDataSources);

        // Slave DataSource 가져올 때 사용할 Name 정의
        List<String> slaves = targetDataSources.keySet().stream()
            .map(Object::toString)
            .filter(string -> string.startsWith("slave"))
            .collect(Collectors.toList());

        slaveNames = slaves;
    }

    // 연결하고자하는 DataSource 이름을 결정하는 로직을 구현해주는 부분 (핵심)
    @Override
    protected String determineCurrentLookupKey() {
        boolean isReadOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();

        // Transaction이 read-only면 Slave중 하나에 연결
        if (isReadOnly) {
            String slaveName = getNextSlaveName();

            LOGGER.info("Connected Slave DB Name : {}", slaveName);

            return slaveName;
        }

        LOGGER.info("Connected Master DB Name : {}", MASTER_NAME);
        return MASTER_NAME;
    }

    private String getNextSlaveName() {
        String nextSlave = slaveNames.get(counter);
        counter = (counter + 1) % slaveNames.size();
        return nextSlave;
    }
}

@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class)
@EnableConfigurationProperties(DataSourceProperties.class)
@Configuration
public class ReplicationDataSourceConfiguration {

    private final DataSourceProperties dataSourceProperties;
    private final JpaProperties jpaProperties;

    public ReplicationDataSourceConfiguration(
        DataSourceProperties dataSourceProperties,
        JpaProperties jpaProperties
    ) {
        this.dataSourceProperties = dataSourceProperties;
        this.jpaProperties = jpaProperties;
    }

    // 1
    @Bean
    public DataSource routingDataSource() {

        // DataSource 설정
        Map<Object, Object> dataSources = new HashMap<>();
        DataSource master = createDataSource(dataSourceProperties.getMaster());
        dataSources.put("master", master);
        dataSourceProperties.getSlave().forEach((key, value) ->
            dataSources.put(key, createDataSource(value))
        );

        // 라운드 로빈 방식의 DataSource 정의
        ReplicationRoutingDataSource replicationRoutingDataSource
            = new ReplicationRoutingDataSource();
        replicationRoutingDataSource.setDefaultTargetDataSource(master);
        replicationRoutingDataSource.setTargetDataSources(dataSources);
        return replicationRoutingDataSource;
    }

    private DataSource createDataSource(DatasourceNode datasourceNode) {
        return DataSourceBuilder.create()
            .type(HikariDataSource.class)
            .url(datasourceNode.getUrl())
            .driverClassName("com.mysql.cj.jdbc.Driver")
            .username(datasourceNode.getUsername())
            .password(datasourceNode.getPassword())
            .build();
    }

    // 2
    // 실제 쿼리가 실행될 때마다 DataSource 가져오도록 Lazy로 빈 등록
    @Bean
    public DataSource dataSource() {
        return new LazyConnectionDataSourceProxy(routingDataSource());
    }

    // 3
    // JPA에서 사용되는 EntityManagerFactory 설정 (LazyConnectionDataSourceProxy를 넣기 위함)
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        EntityManagerFactoryBuilder entityManagerFactoryBuilder = createEntityManagerFactoryBuilder(jpaProperties);
        return entityManagerFactoryBuilder.dataSource(dataSource())
            .packages("com.binghe.springbootdbreplication") // 프로젝트 패키지 경로
            .build();
    }

    private EntityManagerFactoryBuilder createEntityManagerFactoryBuilder(JpaProperties jpaProperties) {
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        return new EntityManagerFactoryBuilder(vendorAdapter, jpaProperties.getProperties(), null);
    }

    // 4
    // JPA에서 사용할 TransactionManager 설정 (entityManagerFactory로 인해 정의해준다)
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager tm = new JpaTransactionManager();
        tm.setEntityManagerFactory(entityManagerFactory);
        return tm;
    }
}

@Entity
public class User {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private int age;

    // 생성자, Getter, Setter
}

public interface UserRepository extends CrudRepository<User, Long> {
}

@Service
public class UserService {

    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional(readOnly = true)
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("존재하지 않는 유저"));
    }

    @Transactional
    public User save(User user) {
        return userRepository.save(user);
    }
}

@DisplayName("UserService와 로깅을 이용한 Master 쓰기 및 Slave 조회 테스트")
@AutoConfigureTestDatabase(replace = Replace.NONE) // Test환경에서 H2 DataSource 자동연결을 비활성화.
@SpringBootTest(webEnvironment = WebEnvironment.NONE)
public class ReplicationUserServiceTest {

    @Autowired
    private UserService userService;

    @DisplayName("Master 쓰기 및 Slave 조회 테스트 (로깅을 이용)")
    @Test
    void save() {
        // given
        User user = new User(null, "mark", 26);
        User savedUser = userService.save(user);

        // when
        User findUser = userService.findById(savedUser.getId());
        User findUser2 = userService.findById(savedUser.getId());
        User findUser3 = userService.findById(savedUser.getId());

        // then
        assertThat(findUser)
            .usingRecursiveComparison()
            .isEqualTo(savedUser);
        assertThat(findUser2)
            .usingRecursiveComparison()
            .isEqualTo(savedUser);
        assertThat(findUser3)
            .usingRecursiveComparison()
            .isEqualTo(savedUser);
    }
}