Kotlin 绑定自定义数据类型将null传输到转换器

我在我的项目中使用了Jooq和Kotlin。我有一个对象EventEnvelope，其中包含类型为Event的字段。我想在我的数据库（postgres）中将此字段存储为JSON。我准备了jooq自定义数据类型绑定和转换器，如这里所述-> 下面我粘贴转换器、绑定和渐变生成器代码

我的问题是：

将kotlin非null类型与jooq绑定一起使用可以吗

这个配置可以吗？我应该换什么

当我想存储值时，我的转换器从func中得到null。我不知道这是为什么

我不知道该怎么做才能解决它

class JSONEventConverter constructor(
    private val objectMapper: ObjectMapper,
    private val schemaMatcher: SchemaMatcher
) : Converter<Any, Event> {
    override fun from(databaseObject: Any): Event {
        return schemaMatcher.parse(databaseObject.toString())
    }

    override fun to(userObject: Event): Any {
        return objectMapper.writeValueAsString(userObject)
    }

    override fun fromType(): Class<Any> {
        return Any::class.java
    }

    override fun toType(): Class<Event> {
        return Event::class.java
    }

    companion object {
        fun create(): JSONEventConverter {
            return JSONEventConverter(jacksonObjectMapper(), 
                SchemaMatcher.create())
        }
    }
}

class PostgresJSONEventBinding : Binding<Any, Event> {
    override fun register(ctx: BindingRegisterContext<Event>?) {
        ctx!!.statement().registerOutParameter(ctx.index(), Types.VARCHAR)
    }

    override fun sql(ctx: BindingSQLContext<Event>?) {
        ctx!!.render().visit(DSL.`val`(ctx.convert(converter())
            .value())).sql("::json")
    }

    override fun converter(): Converter<Any, Event> {
        return JSONEventConverter.create()
    }

    override fun get(ctx: BindingGetResultSetContext<Event>?) {     
        ctx!!.convert(converter())
            .value(ctx.resultSet().getString(ctx.index()))
    }

    override fun get(ctx: BindingGetStatementContext<Event>?) {
        ctx!!.convert(converter())
            .value(ctx.statement().getString(ctx.index()))
    }

    override fun get(ctx: BindingGetSQLInputContext<Event>?) {
        throw SQLFeatureNotSupportedException()
    }

    override fun set(ctx: BindingSetStatementContext<Event>?) {
        ctx!!.statement().setString(ctx.index(), 
            Objects.toString(ctx.convert(converter()).value(), null))
    }

    override fun set(ctx: BindingSetSQLOutputContext<Event>?) {
        throw SQLFeatureNotSupportedException()
    }
}

generator {
    name = 'org.jooq.util.DefaultGenerator'
    strategy {
        name = 'org.jooq.util.DefaultGeneratorStrategy'
    }
    database {
        name = 'org.jooq.util.postgres.PostgresDatabase'
        schemata {
            schema {
                inputSchema = someSchema
            }
            schema {
                inputSchema = otherSchema
            }
        }
        forcedTypes {
            forcedType {
                userType = 'package.Event'
                binding = 'package.PostgresJSONEventBinding'
                expression = 'someSchema\\.event_store\\.event'
            }
        }
    }
    generate {
        relations = true
        deprecated = false
        records = true
        immutablePojos = true
        fluentSetters = true
    }
    target {
        packageName = appName
    }
}

类JSONEventConverter构造函数(
私有val对象映射器：对象映射器，
私有val schemaMatcher:schemaMatcher
)：转换器{
覆盖来自（数据库对象：任意）：事件{
返回schemaMatcher.parse（databaseObject.toString（））
}
覆盖乐趣到（userObject:Event）：任意{
返回objectMapper.writeValueAsString（userObject）
}
重写fromType（）：类{
返回Any:：class.java
}
重写fun toType（）：类{
返回事件：：class.java
}
伴星{
乐趣创建（）：JSONEventConverter{
返回JSONEventConverter（JacksonObject映射器（），
SchemaMatcher.create（））
}
}
}
类PostgresJSONEventBinding:绑定{
覆盖有趣的寄存器（ctx:BindingRegisterContext？）{
ctx！！.statement（）.registerOutParameter（ctx.index（），Types.VARCHAR）
}
重写有趣的sql（ctx:BindingSQLContext？）{
ctx！！.render（）.visit（DSL.val`）（ctx.convert（converter（））
.value（））.sql（“：：json”）
}
覆盖乐趣转换器（）：转换器{
返回JSONEventConverter.create（）
}
覆盖有趣的获取（ctx:bindingGetResultContext？{
ctx！！.convert（converter（））
.value（ctx.resultSet（）.getString（ctx.index（）））
}
重写fun-get（ctx:BindingGetStatementContext？）{
ctx！！.convert（converter（））
.value（ctx.statement（）.getString（ctx.index（）））
}
重写fun-get（ctx:BindingGetSQLInputContext？）{
抛出SQLFeatureNotSupportedException（）
}
覆盖乐趣集（ctx:BindingSetStatementContext？）{
ctx！！.statement（）.setString（ctx.index（），
Objects.toString（ctx.convert（converter（））.value（），null））
}
覆盖乐趣集（ctx:BindingSetSQLOutputContext？）{
抛出SQLFeatureNotSupportedException（）
}
}
发电机{
name='org.jooq.util.DefaultGenerator'
策略{
name='org.jooq.util.DefaultGeneratorStrategy'
}
数据库{
name='org.jooq.util.postgres.PostgresDatabase'
图式{
模式{
inputSchema=someSchema
}
模式{
inputSchema=otherSchema
}
}
强制类型{
强制打字{
userType='package.Event'
binding='package.PostgresJSONEventBinding'
表达式='someSchema\\.event\\.store\\.event'
}
}
}
产生{
关系=真
不推荐=错误
记录=真
immutablePojos=true
fluentSetters=true
}
目标{
packageName=appName
}
}

将kotlin非null类型与jooq绑定一起使用可以吗

jOOQ（或任何Java库）都不会遵守Kotlin不可为null的保证，并且可能会在您不希望的地方生成null值。所以，也许这毕竟不是一个好主意

在jOOQ和代码之间的接口处，您必须确保这不会发生

这个配置可以吗？我应该换什么

这是一个开放的问题。如果您有任何具体问题，请询问

当我想存储值时，我的转换器从func中得到null。我不知道这是为什么

---

您的问题中没有足够的信息来帮助您解决这个问题，所以在我的例子中，是关于java中可空类型和kotlin中非空类型之间的java kotlin互操作性。我所要做的就是在kotlin中使用可为null的类型（那些带有

？

）实现转换器

正确的转换器如下所示：

class JSONEventConverter constructor(
    private val objectMapper: ObjectMapper,
    private val schemaMatcher: SchemaMatcher
) : Converter<Any, Event> {
    override fun from(databaseObject: Any?): Event? {
        return databaseObject?.let { schemaMatcher.parse(it.toString()) }
    }

    override fun to(userObject: Event?): Any? {
        return userObject?.let { objectMapper.writeValueAsString(it) }
    }

    override fun fromType(): Class<Any> {
        return Any::class.java
    }

    override fun toType(): Class<Event> {
        return Event::class.java
    }

    companion object {
        fun create(): JSONEventConverter {
            return JSONEventConverter(serializingObjectMapper(),         
                SchemaMatcher.create())
        }
    }
}

类JSONEventConverter构造函数(
私有val对象映射器：对象映射器，
私有val schemaMatcher:schemaMatcher
)：转换器{
覆盖来自（databaseObject:任何？）：事件的乐趣{
返回databaseObject？.let{schemaMatcher.parse（it.toString（））}
}
将乐趣覆盖到（userObject:Event？）：有吗{
返回userObject？.let{objectMapper.writeValueAsString（it）}
}
重写fromType（）：类{
返回Any:：class.java
}
重写fun toType（）：类{
返回事件：：class.java
}
伴星{
乐趣创建（）：JSONEventConverter{
返回JSONEventConverter（serializingObjectMapper（），
SchemaMatcher.create（））
}
}
}

您的问题将3个问题混合在一起。在这里，很难知道你真正想要的是什么。你到底遇到了什么问题？试着把你的问题集中在那个问题上。回答起来容易多了。谢谢你（一如既往）的回答。我又在想我的问题，为了精确我的问题，我解决了它。谢谢你鼓舞人心的回答。既然这个问题没用，我应该把它去掉吗？@Piotrowy:不，不要把它去掉。你自己回答！：-）其他人可能仍然觉得它有用。。。