如何获取给定密封类的所有子类？

Question

最近我们将其中一个枚举类升级为密封类将对象作为子类，这样我们就可以创建另一层抽象来简化代码。但是，我们不能再通过Enum.values() 函数获得所有可能的子类，这很糟糕，因为我们严重依赖该功能。有没有办法通过反射或任何其他工具来检索这些信息？

PS：手动将它们添加到数组中是不可接受的。目前有 45 个，并且计划增加更多。

---

这就是我们的密封类的样子：

sealed class State

object StateA: State()
object StateB: State()
object StateC: State()
....// 42 more

如果有一个 values 集合，它将是这个形状：

val VALUES = setOf(StateA, StateB, StateC, StateC, StateD, StateE,
    StateF, StateG, StateH, StateI, StateJ, StateK, StateL, ......

自然没有人愿意养这样一个怪物。

Answer 1

在 Kotlin 1.3+ 中，您可以使用 sealedSubclasses。

在以前的版本中，如果您将子类嵌套在基类中，则可以使用nestedClasses：

Base::class.nestedClasses

如果您在基类中嵌套其他类，则需要添加过滤。例如：

Base::class.nestedClasses.filter { it.isFinal && it.isSubclassOf(Base::class) }

请注意，这会为您提供子类，而不是这些子类的实例（与 Enum.values() 不同）。

---

对于您的特定示例，如果您在 State 中的所有嵌套类都是您的 object 状态，那么您可以使用以下内容获取所有实例（如 Enum.values()）：

State::class.nestedClasses.map { it.objectInstance as State }

---

如果你想变得更花哨，你甚至可以扩展Enum<E: Enum<E>> 并使用reflection 从它创建你自己的类层次结构到你的具体对象。例如：

sealed class State(name: String, ordinal: Int) : Enum<State>(name, ordinal) {
    companion object {
        @JvmStatic private val map = State::class.nestedClasses
                .filter { klass -> klass.isSubclassOf(State::class) }
                .map { klass -> klass.objectInstance }
                .filterIsInstance<State>()
                .associateBy { value -> value.name }

        @JvmStatic fun valueOf(value: String) = requireNotNull(map[value]) {
            "No enum constant ${State::class.java.name}.$value"
        }

        @JvmStatic fun values() = map.values.toTypedArray()
    }

    abstract class VanillaState(name: String, ordinal: Int) : State(name, ordinal)
    abstract class ChocolateState(name: String, ordinal: Int) : State(name, ordinal)

    object StateA : VanillaState("StateA", 0)
    object StateB : VanillaState("StateB", 1)
    object StateC : ChocolateState("StateC", 2)
}

这样您就可以像使用任何其他 Enum 一样调用以下命令：

State.valueOf("StateB")
State.values()
enumValueOf<State>("StateC")
enumValues<State>()

---

更新

Kotlin 不再支持直接扩展 Enum。看 Disallow to explicitly extend Enum class : KT-7773.

Answer 2

使用 Kotlin 1.3+，您可以使用反射列出所有密封的子类，而无需使用嵌套类：https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/-k-class/sealed-subclasses.html

我要求一些功能来实现相同的功能而无需反射：https://discuss.kotlinlang.org/t/list-of-sealed-class-objects/10087

Answer 3

完整示例：

sealed class State{
    companion object {
        fun find(state: State) =
            State::class.sealedSubclasses
                    .map { it.objectInstance as State}
                    .firstOrNull { it == state }
                    .let {
                        when (it) {
                            null -> UNKNOWN
                            else -> it
                        }
                    }
    }
    object StateA: State()
    object StateB: State()
    object StateC: State()
    object UNKNOWN: State()

}

Answer 4

明智的选择是在 kotlin 中使用 ServiceLoader。然后编写一些提供程序来获取一个通用的类、枚举、对象或数据类实例。例如：

val provides = ServiceLoader.load(YourSealedClassProvider.class).iterator();

val subInstances =  providers.flatMap{it.get()};

fun YourSealedClassProvider.get():List<SealedClass>{/*todo*/};

层次结构如下：

                Provider                    SealedClass
                   ^                             ^
                   |                             |
            --------------                --------------
            |            |                |            |
        EnumProvider ObjectProvider    ObjectClass  EnumClass
            |            |-------------------^          ^
            |                    <uses>                 |
            |-------------------------------------------|
                                 <uses>

---

另一个选项更复杂，但它可以满足您的需求，因为在同一个包中密封类。让我告诉你如何以这种方式归档：

1. 获取密封类的 URL，例如：ClassLoader.getResource("com/xxx/app/YourSealedClass.class")
2. 扫描所有密封类URL父级的jar条目/目录文件，例如：jar://**/com/xxx/app或file://**/com/xxx/app，然后找出所有"com/xxx/app/*.class"文件/条目。
3. 使用ClassLoader.loadClass(eachClassName) 加载过滤的类
4. 检查加载的类是否是你的密封类的子类
5. 决定如何获取子类实例，例如：Enum.values()、object.INSTANCE。
6. 返回已创建的密封类的所有实例

Answer 5

如果你想在孩子课堂上使用它，试试这个。

open class BaseSealedClass(val value: String, val name: Int) {
    companion object {
        inline fun<reified T:BaseSealedClass> valueOf(value: String): T? {
            return T::class.nestedClasses
                .filter { clazz -> clazz.isSubclassOf(T::class) }
                .map { clazz -> clazz.objectInstance }
                .filterIsInstance<T>()
                .associateBy { it.value }[value]
        }

        inline fun<reified  T:BaseSealedClass> values():List<T> =
            T::class.nestedClasses
            .filter { clazz -> clazz.isSubclassOf(T::class) }
            .map { clazz -> clazz.objectInstance }
            .filterIsInstance<T>()
    }
}

@Stable
sealed class Theme(value: String, name: Int): BaseSealedClass(value, name) {
    object Auto: Theme(value = "auto", name = R.string.setting_general_theme_auto)
    object Light: Theme(value= "light", name = R.string.setting_general_theme_light)
    object Dark: Theme(value= "dark", name = R.string.setting_general_theme_dark)

    companion object {
        fun valueOf(value: String): Theme? = BaseSealedClass.valueOf(value)
        fun values():List<Theme> = BaseSealedClass.values()
    }
}

Answer 6

对于没有反射的解决方案，这是一个支持在编译时为密封类生成类型列表的库： https://github.com/livefront/sealed-enum

文档中的示例

sealed class Alpha {
    object Beta : Alpha()
    object Gamma : Alpha()
    
    @GenSealedEnum
    companion object
}

将生成以下对象：

object AlphaSealedEnum : SealedEnum<Alpha> {
    override val values: List<Alpha> = listOf(
        Alpha.Beta,
        Alpha.Gamma
    )

    override fun ordinalOf(obj: Alpha): Int = when (obj) {
        Alpha.Beta -> 0
        Alpha.Gamma -> 1
    }

    override fun nameOf(obj: AlphaSealedEnum): String = when (obj) {
        Alpha.Beta -> "Alpha_Beta"
        Alpha.Gamma -> "Alpha_Gamma"
    }

    override fun valueOf(name: String): AlphaSealedEnum = when (name) {
        "Alpha_Beta" -> Alpha.Beta
        "Alpha_Gamma" -> Alpha.Gamma
        else -> throw IllegalArgumentException("""No sealed enum constant $name""")
    }
  }