Question

我正在使用ByteBuddy来修改另一个库的类，以便为它添加Spring依赖注入。问题是我无法实例化用作拦截器的类，这意味着我无法使用Spring将ApplicationContext注入到拦截器中。

为了解决这个问题，我创建了一个对象StaticAppContext，它通过实现ApplicationContext来注入ApplicationContextAware：

@Component
object StaticAppContext : ApplicationContextAware {
    private val LOGGER = getLogger(StaticAppContext::class)

    @Volatile @JvmStatic lateinit var context: ApplicationContext

    override fun setApplicationContext(applicationContext: ApplicationContext?) {
        context = applicationContext!!
        LOGGER.info("ApplicationContext injected")
    }
}

这样注入就好了（我可以看到日志消息），但是当我尝试从拦截器访问ApplicationContext时，我得到kotlin.UninitializedPropertyAccessException: lateinit property context has not been initialized。

修改类和incerceptor的类在此类中定义：

package nu.peg.discord.d4j

import net.bytebuddy.ByteBuddy
import net.bytebuddy.dynamic.ClassFileLocator
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy
import net.bytebuddy.implementation.MethodDelegation
import net.bytebuddy.implementation.SuperMethodCall
import net.bytebuddy.implementation.bind.annotation.*
import net.bytebuddy.matcher.ElementMatchers
import net.bytebuddy.pool.TypePool
import nu.peg.discord.config.BeanNameRegistry.STATIC_APP_CONTEXT
import nu.peg.discord.config.StaticAppContext
import nu.peg.discord.util.getLogger
import org.springframework.beans.BeansException
import org.springframework.beans.factory.config.AutowireCapableBeanFactory
import org.springframework.context.annotation.DependsOn
import org.springframework.stereotype.Component
import sx.blah.discord.api.IDiscordClient
import sx.blah.discord.modules.Configuration
import sx.blah.discord.modules.IModule
import sx.blah.discord.modules.ModuleLoader
import java.lang.reflect.Constructor
import java.util.ArrayList
import javax.annotation.PostConstruct

/**
 * TODO Short summary
 *
 * @author Joel Messerli @15.02.2017
 */
@Component @DependsOn(STATIC_APP_CONTEXT)
class D4JModuleLoaderReplacer : IModule {
    companion object {
        private val LOGGER = getLogger(D4JModuleLoaderReplacer::class)
    }

    @PostConstruct
    fun replaceModuleLoader() {
        val pool = TypePool.Default.ofClassPath()

        ByteBuddy().rebase<Any>(
                pool.describe("sx.blah.discord.modules.ModuleLoader").resolve(), ClassFileLocator.ForClassLoader.ofClassPath()
        ).constructor(
                ElementMatchers.any()
        ).intercept(
                SuperMethodCall.INSTANCE.andThen(MethodDelegation.to(pool.describe("nu.peg.discord.d4j.SpringInjectingModuleLoaderInterceptor").resolve()))
        ).make().load(ClassLoader.getSystemClassLoader(), ClassLoadingStrategy.Default.INJECTION)

        LOGGER.info("The D4J ModuleLoader has been replaced with ByteBuddy to allow for Spring injection")
    }

    override fun getName() = "Spring Injecting Module Loader"
    override fun enable(client: IDiscordClient?) = true
    override fun getVersion() = "1.0.0"
    override fun getMinimumDiscord4JVersion() = "1.7"
    override fun getAuthor() = "Joel Messerli <hi.github@peg.nu>"
    override fun disable() {}
}

class SpringInjectingModuleLoaderInterceptor {
    companion object {
        private val LOGGER = getLogger(SpringInjectingModuleLoaderInterceptor::class)

        @Suppress("UNCHECKED_CAST")
        @JvmStatic
        fun <T> intercept(
                @This loader: ModuleLoader,
                @Origin ctor: Constructor<T>,
                @Argument(0) discordClient: IDiscordClient?,

                @FieldValue("modules") modules: List<Class<out IModule>>,
                @FieldValue("loadedModules") loadedModules: MutableList<IModule>
        ) {
            LOGGER.debug("Intercepting $ctor")
            val loaderClass = loader.javaClass
            val clientField = loaderClass.getDeclaredField("client")
            clientField.isAccessible = true
            clientField.set(loader, discordClient)

            val canModuleLoadMethod = loaderClass.getDeclaredMethod("canModuleLoad", IModule::class.java)
            canModuleLoadMethod.isAccessible = true

            val factory = StaticAppContext.context.autowireCapableBeanFactory
            for (moduleClass in modules) {
                try {
                    val wired = factory.autowire(moduleClass, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false) as IModule
                    LOGGER.info("Loading autowired module {}@{} by {}", wired.name, wired.version, wired.author)
                    if (canModuleLoadMethod.invoke(loader, wired) as Boolean) {
                        loadedModules.add(wired)
                    } else {
                        LOGGER.info("${wired.name} needs at least version ${wired.minimumDiscord4JVersion} to be loaded (skipped)")
                    }
                } catch (e: BeansException) {
                    LOGGER.info("Spring could not create bean", e)
                }
            }

            if (Configuration.AUTOMATICALLY_ENABLE_MODULES) { // Handles module load order and loads the modules
                val toLoad = ArrayList<IModule>(loadedModules)

                val loadModuleMethod = loaderClass.getDeclaredMethod("loadModule", IModule::class.java)
                while (toLoad.size > 0) {
                    toLoad.filter { loadModuleMethod.invoke(loader, it) as Boolean }.forEach { toLoad.remove(it) }
                }
            }
            LOGGER.info("Module loading complete")
        }
    }
}

当我调试它时，IntelliJ显示当拦截器试图访问StaticAppContext时会创建一个新的StaticAppContext实例，这是有意义的，因为抛出了异常。

当从生成的代码调用时，Kotlin对象不是真正的单身人士，还是我做错了什么？有什么方法可以解决这个问题？

该项目也可以在Github上找到：https://github.com/jmesserli/discord-bernbot/tree/master/src/main/kotlin/nu/peg/discord

修改
我通过删除spring-boot-devtools添加了自己的ClassLoader来解决问题。当我尝试使用Thread.currentThread().contextClassLoader的建议时，我得到了一个不同的异常，告诉我它已经被另一个ClassLoader加载（这证实它是ClassLoader s的问题）。此外，似乎可能存在种族的假设是正确的。

我现在有一个不同的问题，我会做一些研究，看看我是否可以自己解决。

Answer 1

将Kotlin object编译为以下布局：

public final class StaticAppContext {
  public static final StaticAppContext INSTANCE;
  private StaticAppContext();
  static {}
}

这个类隐含着一个单身人士。因此我想知道这个问题是否是课堂上的比赛。很可能已经调用了静态初始化程序。您确定收到了正确的日志消息吗？

Answer 2

免责声明：我是一名业余爱好程序员，尚未与Spring合作过。根据我听到的有关Spring的内容，这里有一堆猜测。

我有预感这可能是一个类加载器问题 - 由于您在StaticAppContext中使用了ClassLoader.getSystemClassLoader()，因此可能会在2个不同的类加载器中加载2个D4JModuleLoaderReplacer.replaceModuleLoader()类。

要确认这一点，请在StaticAppContext块中记录init { ... }对象的创建。例如：

@Component object StaticAppContext : ApplicationContextAware { private val LOGGER = getLogger(StaticAppContext::class) init { LOGGER.info("StaticAppContext created. Classloader: ${javaClass.classLoader}") } ... }

如果我的理论是正确的，你应该得到2条创建日志消息。

如果是这种情况，我相信您应该使用当前的上下文类加载器（Thread.currentThread().getContextClassLoader()）。

在运行时生成的类中使用Kotlin对象

2 个答案: