Blocking problem of graphql-kotlin with DataLoader&BatchLoader

Question

I used the framework "https://github.com/ExpediaGroup/graphql-kotlin" to learn graphql programming of kotlin under springframework.

I used DataLoader&BatchLoader to resolve the 'N+1' loading problem.

When the scope of DataLoader objects is singleton, it works, but it's not my goal because temporary cache mechanism should not be bridging over different requests.

Then I changed the scope of DataLoader objects to be prototype, in all probability, the graphql query may be blocking and associated objects will not be loaded, client waits the response forever.

What's the reason and how can I resolve it?

---

I did it like this:

1. Create a simple springboot application, add maven dependency of graph-kotlin

<dependency>
   <groupId>com.expediagroup</groupId>
   <artifactId>graphql-kotlin-spring-server</artifactId>
   <version>2.0.0.RC3</version>
</dependency>

2. Create two model classes(Note: Their code will be changed in the final step)

data class Department(
    val id: Long,
    val name: String
)
data class Employee(
    val id: Long,
    val name: String,
    @GraphQLIgnore val departmentId: Long
)

3. Create two mocked repository objects

val DEPARTMENTS = listOf(
    Department(1L, "Develop"),
    Department(2L, "Test")
)
val EMPLOYEES = listOf(
    Employee(1L, "Jim", 1L),
    Employee(2L, "Kate", 1L),
    Employee(3L, "Tom", 2L),
    Employee(4L, "Mary", 2L)
)

@Repository
open class DepartmentRepository {

    companion object {
        private val LOGGER = LoggerFactory.getLogger(DepartmentRepository::class.java)
    }

    open fun findByName(namePattern: String?): List<Department> = //For root query
        namePattern
            ?.takeIf { it.isNotEmpty() }
            ?.let { pattern ->
                DEPARTMENTS.filter { it.name.contains(pattern) }
            }
            ?: DEPARTMENTS

    open fun findByIds(ids: Collection<Long>): List<Department> { // For assciation
        LOGGER.info("BatchLoad departments by ids: [${ids.joinToString(", ")}]")
        return DEPARTMENTS.filter { ids.contains(it.id) }
    }
}

@Repository
open class EmployeeRepository {

    companion object {
        private val LOGGER = LoggerFactory.getLogger(EmployeeRepository::class.java)
    }

    open fun findByName(namePattern: String?): List<Employee> = //For root query
        namePattern
            ?.takeIf { it.isNotEmpty() }
            ?.let { pattern ->
                EMPLOYEES.filter { it.name.contains(pattern) }
            }
            ?: EMPLOYEES

    open fun findByDepartmentIds(departmentIds: Collection<Long>): List<Employee> { // For association
        LOGGER.info("BatchLoad employees by departmentIds: [${departmentIds.joinToString(", ")}]")
        return EMPLOYEES.filter { departmentIds.contains(it.departmentId) }
    }
}

4. Create a graphql query object to export root query operations

@Service
open class OrgService(
    private val departmentRepository: DepartmentRepository,
    private val employeeRepository: EmployeeRepository
) : Query {

    fun departments(namePattern: String?): List<Department> =
       departmentRepository.findByName(namePattern)

    fun employees(namePattern: String?): List<Employee> =
        employeeRepository.findByName(namePattern)
}

5. Create an abstract class for many-to-one associated object loading

abstract class AbstractReferenceLoader<K, R: Any> (
    batchLoader: (Collection<K>) -> Collection<R>,
    keyGetter: (R) ->K,
    optionsInInitializer: (DataLoaderOptions.() -> Unit) ? = null
): DataLoader<K, R?>(
    { keys ->
        CompletableFuture.supplyAsync {
            batchLoader(keys)
                .associateBy(keyGetter)
                .let { map ->
                    keys.map { map[it] }
                }
        }
    },
    optionsInInitializer?.let {
        DataLoaderOptions().apply {
            this.it()
        }
    }
)

6. Create an abstract class for one-to-many associated collection loading

abstract class AbstractListLoader<K, E>(
    batchLoader: (Collection<K>) -> Collection<E>,
    keyGetter: (E) ->K,
    optionsInInitializer: (DataLoaderOptions.() -> Unit) ? = null
): DataLoader<K, List<E>>(
    { keys ->
        CompletableFuture.supplyAsync {
            batchLoader(keys)
                .groupBy(keyGetter)
                .let { map ->
                    keys.map { map[it] ?: emptyList() }
                }
        }
    },
    optionsInInitializer?.let {
        DataLoaderOptions().apply {
            this.it()
        }
    }
)

7. Create annotation to let spring manager DataLoader beans by prototype scope

@Retention(RetentionPolicy.RUNTIME)
@Target(AnnotationTarget.CLASS)
@Component
@Scope(
    ConfigurableBeanFactory.SCOPE_PROTOTYPE,
    proxyMode = ScopedProxyMode.NO
)
annotation class DataLoaderComponent

8. Create loader bean to load the parent object reference of Employee object

@DataLoaderComponent
open class DepartmentLoader(
    private val departmentRepository: DepartmentRepository
): AbstractReferenceLoader<Long, Department>(
    { departmentRepository.findByIds(it) },
    { it.id },
    { setMaxBatchSize(256) }
)

9. Create loader bean to load the child object collection of Department object

@DataLoaderComponent
open class EmployeeListByDepartmentIdLoader(
    private val employeeRepository: EmployeeRepository
): AbstractListLoader<Long, Employee>(
    { employeeRepository.findByDepartmentIds(it) },
    { it.departmentId },
    { setMaxBatchSize(16) }
)

8. Create an GraphQL configuration to let 'graphql-kotlin' know all the DataLoader beans

@Configuration
internal abstract class GraphQLConfig {

    @Bean
    open fun dataLoaderRegistryFactory(): DataLoaderRegistryFactory =
        object: DataLoaderRegistryFactory {
            override fun generate(): DataLoaderRegistry = dataLoaderRegistry()
        }

    @Bean
    @Scope(
        ConfigurableBeanFactory.SCOPE_PROTOTYPE,
        proxyMode = ScopedProxyMode.NO
    )
    protected open fun dataLoaderRegistry(
        loaders: List<DataLoader<*, *>>
    ): DataLoaderRegistry =
        DataLoaderRegistry().apply {
            loaders.forEach { loader ->
                register(
                    loader::class.qualifiedName,
                    loader
                )
            }
        }

    @Lookup
    protected abstract fun dataLoaderRegistry(): DataLoaderRegistry
}

9. Add tow methods into DataFetchingEnvironment to get DataLoader objects

inline fun <reified L: AbstractReferenceLoader<K, R>, K, R> DataFetchingEnvironment.getReferenceLoader(
): DataLoader<K, R?> =
    this.getDataLoader<K, R?>(L::class.qualifiedName)

inline fun <reified L: AbstractListLoader<K, E>, K, E> DataFetchingEnvironment.getListLoader(
): DataLoader<K, List<E>> =
    this.getDataLoader<K, List<E>>(L::class.qualifiedName)

10. Change the code of Department and Employee, let them support association

data class Department(
    val id: Long,
    val name: String
) {
    suspend fun employees(env: DataFetchingEnvironment): List<Employee> =
        env
            .getListLoader<EmployeeListByDepartmentIdLoader, Long, Employee>()
            .load(id)
            .await()
}

data class Employee(

    val id: Long,
    val name: String,

    @GraphQLIgnore val departmentId: Long
) {
    suspend fun department(env: DataFetchingEnvironment): Department? =
        env
            .getReferenceLoader<DepartmentLoader, Long, Department>()
            .load(departmentId)
            .await()
}

---

Build & Run

1. Start the SpringBoot applications, open http://locathost:8080/playground.
2. Execute the query, the result may be success or failed!

{
  employees {
    id
    name
    department {
      id
      name
      employees {
        id
        name
      }
    }
  }
}

3. If it is success, the client can get the response, and the server log is

2020-03-15 22:47:26.366  INFO 35616 --- [onPool-worker-5] org.frchen.dal.DepartmentRepository      : BatchLoad departments by ids: [1, 2]
2020-03-15 22:47:26.367  INFO 35616 --- [onPool-worker-5] org.frchen.dal.EmployeeRepository        : BatchLoad employees by departmentIds: [1, 2]

4. If it is failed, the client is blocking and waits for the response forever, and the server log is

2020-03-15 22:53:43.159  INFO 35616 --- [onPool-worker-6] org.frchen.dal.DepartmentRepository      : BatchLoad departments by ids: [1, 2]