blocks|key|1773256|text|(免责声明:我是通过创建Quarkus扩展使Hibernate+ORM在GraalVM本地映像上工作的人之一。我还领导着Hibernate研发团队。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1773257|谢谢你给我这个机会写下一点历史:)|1773258|最初，我们没有使用Quarkus，因为它还不存在。|1773259|我最初的原型只是修补Hibernate+ORM，并堆积了许多编译器开关，以传递给本机映像工具，在bash脚本中硬编码，直到我的演示应用程序开始工作为止。|1773260|这种方法的问题在于，许多这样的标志实际上取决于Hibernate+ORM的内部知识，以及域模型的细节、配置细节，以及更多细节。|1773261|我开始记录这样的事情，但它变得复杂和多毛；不仅仅是不同的方面相互依赖；而且，我的演示应用程序相当简单，而且在实际应用程序中，事情必然会变得更加复杂.我不认为我们能够写一份好的文件，这将是既简单又“可以理解”。|1773262|让最终用户保持简单的另一种选择是“启用对所有这些类的反映，因为您可能会使用它们”，但我有点喜欢优化，这会创建更大、更臃肿的二进制文件，而不是只包含和单独包含应用程序真正需要的所有东西时。|1773263|所以我们的团队决定写一个工具来自动化这些细节。它变成了一个构建工具，它分析应用程序，找出使用的最佳开关。与其只关注Hibernate+ORM，我们还创建了“扩展”的概念，它也知道如何对其他库使用相同的技巧，这样您就可以从使用支持的库(而不仅仅是Hibernate+)的更复杂应用程序中获得高度优化的二进制文件。|1773264|显然，这是必要的，因为不同的库可能有相互冲突的需求，每个库的编译器标志和最终用户的代码的组合都需要合并到一组一致的兼容标志中。|1773265|这就是夸库斯成为一件事的原因:)|1773266|要了解这方面工作的细节，我建议阅读指南和源代码：|1773267|https://quarkus.io/|unordered-list-item|offset|length|1773268|https://github.com/quarkusio/quarkus|1773269|我还对它在公开演讲中的工作方式作了一些高层次的概述；有一张来自英国Devoxx的好唱片|1773270|https://youtu.be/za5CSBX-UME|1773271|我的演讲专门讨论了Hibernate+ORM；我没有太多时间详细介绍它所做的一切，但是在阅读实际代码之前，它应该是一个很好的介绍。|1773272|如果我不想(或者不能)使用Quarkus怎么办？是否可以使用使用Hibernate的GraalVM+(和SubstrateVM)编译本机映像应用程序？|blockquote|1773273|这是一个公平的问题-这当然是可能的，但夸库斯的团队会很想知道为什么？|1773274|Quarkus所做的所有工作主要是构建时；当然，在现阶段它可能是有限的，因为它是一个非常年轻的项目，但是如果您需要支持其他任何东西，那么在构建脚本中为其核心(或其扩展)贡献更容易，而不是硬编码复杂的编译器标志。同样重要的是，Quarkus社区正在成为讨论如何解决任何可能受到Graal限制的障碍的好地方。|1773275|Hibernate+ORM的所有最复杂的补丁都被合并到Hibernate上游存储库中，因此所有重要的补丁都包含在最近的版本中。|1773276|假设您想保持对Quarkus的了解(我不建议这样做，但假设您想学习.)，您仍然需要修改反射规则，实际上Quarkus限制了一些特性，最显著的是一些细节仍然“正在进行中”，或者我们认为人们不应该再使用的东西:)|1773277|具体来说，我和我的队友都不是线程绑定会话的忠实粉丝。我不打算实现对它的支持，除非有人会为它提供一个很好的理由:请打开一个特性请求，或者理想地帮助为它和一个补丁做一个很好的说明？|1773278|https://github.com/quarkusio/quarkus/issues/|1773279|entityMap|0|LINK|mutability|MUTABLE|url|1|2|3^0|0|0|0|0|0|0|0|0|0|0|0|0|J|0|0|0|10|1|0|0|0|S|2|0|0|0|0|0|0|0|0|0|18|3|0^^$0|@$1|2|3|4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|20|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|21|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|22|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|23|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|24|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|25|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|26|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|27|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|28|8|@]|9|@$Y|29|Z|2A|1|2B]]|A|$]]|$1|10|3|11|5|X|7|2C|8|@]|9|@$Y|2D|Z|2E|1|2F]]|A|$]]|$1|12|3|13|5|6|7|2G|8|@]|9|@]|A|$]]|$1|14|3|15|5|X|7|2H|8|@]|9|@$Y|2I|Z|2J|1|2K]]|A|$]]|$1|16|3|17|5|6|7|2L|8|@]|9|@]|A|$]]|$1|18|3|19|5|1A|7|2M|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|X|7|2S|8|@]|9|@$Y|2T|Z|2U|1|2V]]|A|$]]|$1|1N|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]]|1O|$1P|$5|1Q|1R|1S|A|$1T|W]]|1U|$5|1Q|1R|1S|A|$1T|11]]|1V|$5|1Q|1R|1S|A|$1T|15]]|1W|$5|1Q|1R|1S|A|$1T|1M]]]]

(Disclaimer: I'm one of those who made Hibernate ORM work on GraalVM native images, by creating the Quarkus Extensions. I'm also leading the Hibernate R&amp;D team.)

Thank you for this opportunity in writing up a bit of history :)

Initially we were not using Quarkus as it didn't exist yet.

My initial prototypes were just patching Hibernate ORM and piling up many, many compiler switches to be passed to the native-image tool, hardcoded in bash scripts, until I would get my demo application working.

The problem with that approach is that many such flags actually depend on a combination of internal knowledge of Hibernate ORM, AND specifics of your domain model, your configuration details, and probably more.

I started to document such things but it was getting complex and hairy; not least different aspects depend on each other; also, my demo application was rather simple and things were bound to get more complex with real applications... I don't think we'd be able to write a good document which would both be thourough and "understandable".

An alternative to keep things simple for end users would have been "enable reflection on all these classes as you might use them", but I'm a bit of an optimisation freak and that would have created much larger and bloated binaries, than when only and exclusively including all things your application is really going to need.

So our team decided to write a tool which automates such details instead.. it became a bit of a build tool which analyses your application to figure out the best switches to use. And rather than focus on Hibernate ORM only we created the notion of "extensions" which would know how to pull of the same trick for other libraries too, so that you could benefit from highly optimised binaries from more complex applications using a combination of supported libraries, not just Hibernate.

Clearly that was necessary, as different libraries might have conflicting needs, and the combination of compiler flags for each other library and the end user's code needs to be combined in a single consistent set of compatible flags.

So that's how Quarkus became a thing :)

To see details of how this works, I would recommend reading the guides and the source code:

<ul>
<li><a href="https://quarkus.io/" rel="noreferrer">https://quarkus.io/</a></li>
<li><a href="https://github.com/quarkusio/quarkus" rel="noreferrer">https://github.com/quarkusio/quarkus</a></li>
</ul>

I also gave a bit of an high level overview of how it works in public talks; there's a good recording from Devoxx UK

<ul>
<li><a href="https://youtu.be/za5CSBX-UME" rel="noreferrer">https://youtu.be/za5CSBX-UME</a></li>
</ul>

My talk discusses Hibernate ORM specifically; I don't have much time to go in details of all the things it does, but it should serve as a good introduction before reading the actual code for details.

<blockquote>
 What if I don't want to (or can't) use Quarkus? Is it possible to compile a native-image application using GraalVM (and the SubstrateVM) that uses Hibernate?
</blockquote>

That's a fair question - it's certainly possible but the Quarkus team would love to know why?

All of the work Quarkus does is mostly build-time only; sure it might be limited at this stage as it's a very young project, but if you need support for anything else it should be easier to contribute to its core (or to its extensions) than to hardcode complex compiler flags in a build script. Not least, the Quarkus community is becoming a good place to discuss how to solve any roadblock one might hit with the Graal limitations.

All most complex patches to Hibernate ORM have been merged in the Hibernate upstream repositories, so all important patches are included in any recent release.

Assuming you want to stay clear from Quarkus (I'd not suggest that, but assuming you want to learn...), you will still need to tinker with reflection rules, and indeed Quarkus is restricting some features, most notably some details are still "work in progress", or stuff which we don't believe people should be using anymore :)

Specifically, neither me and my team mates are a big fan of thread-bound sessions. I wasn't going to implement support for that unless someone would make a good case for it: please open a feature request, or ideally help to make a good case for it and a patch?

<ul>
<li><a href="https://github.com/quarkusio/quarkus/issues/" rel="noreferrer">https://github.com/quarkusio/quarkus/issues/</a></li>
</ul>

blocks|key|1142440|text|如果您想知道，Quarkus实际上做了什么来启用本地映像，与其创建者：https://www.infoq.com/presentations/quarkus-graalvm-sao-paulo-2019/一起读取文本(或观看视频)？|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1142441|我记得：|1142442|在编译时解析所有注释查找和实体解析。|unordered-list-item|1142443|使用“静态”初始化字段准备一些实例。准备好的实例存储在映像中，并准备在启动时仅在堆上分配。|1142444|如果需要，在编译时生成“代理”|1142445|基本上，Quarkus+(作为gralvm的"plugin“)确实”在应用程序真正连接到数据库的时候启动应用程序“。而不是将内存快照嵌入到jar/本机文件中。|1142446|Quarkus也接触了其他一些库，它们做“禁止”的事情(封闭的世界假设)。|1142447|这将启用“热代码重新加载”，这实际上是在“眨眼”的时间内重新启动整个应用程序。它使用更少的内存和其他美好的东西。|1142448|PS:夸夸斯的小介绍在这里：https://www.infoq.com/news/2019/03/redhat-release-quarkus/|1142449|entityMap|0|LINK|mutability|MUTABLE|url|https://www.infoq.com/presentations/quarkus-graalvm-sao-paulo-2019/|1|https://www.infoq.com/news/2019/03/redhat-release-quarkus/^0|Z|1V|0|0|0|0|0|0|0|0|0|E|1M|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$]]|$1|I|3|J|5|H|7|1A|8|@]|9|@]|C|$]]|$1|K|3|L|5|H|7|1B|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1C|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|1D|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1E|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

If you wold to know, what does Quarkus actually do to enable native image be build, read transcript (or watch video) with its creator: <a href="https://www.infoq.com/presentations/quarkus-graalvm-sao-paulo-2019/" rel="nofollow noreferrer">https://www.infoq.com/presentations/quarkus-graalvm-sao-paulo-2019/</a>

As I remember:

<ul>
<li>in compile time resolves all annotations lookup and entities resolution</li>
<li>prepares some instances with "statically" initialized fields. prepared instances are stored in image and prepared to be just allocated on heap at startup time</li>
<li>generate "proxies" in compile time if needed</li>
<li>basically Quarkus (as "plugin" for gralvm) does "start your application to the point of time, when it does actually connect to database". Than it takes memory snapshot and embed it into jar/native file</li>
<li>Quarkus does also touch some other libraries, which does "forbidden" things (closed world assumptions)</li>
</ul>

This will enable "hot code reload", which actually restarts whole application in a "blink of an eye" time. It uses less memory and other nice things.

PS: little intro to Quarkus is here: <a href="https://www.infoq.com/news/2019/03/redhat-release-quarkus/" rel="nofollow noreferrer">https://www.infoq.com/news/2019/03/redhat-release-quarkus/</a>

The native image compiler in the GraalVM project has, according to the docs, some limitations with dynamic proxies. Since Hibernate makes extensive use of proxies, can it work normally in a project that is ahead-of-time compiled?

The <a href="https://quarkus.io/" rel="nofollow noreferrer">Quarkus</a> project seems to indicate that it can, but my understanding is mainly on the basis of a <a href="https://www.reddit.com/r/graalvm/comments/ayt2qs/hibernate_orm_running_on_quarkus_and_graalvm/" rel="nofollow noreferrer">Reddit post</a> saying 

<blockquote>
 Hibernate ORM can now work even when compiled as GraalVM native images - just make sure you use Quarkus to build the application.
</blockquote>

What if I don't want to (or can't) use Quarkus? Is it possible to compile a native-image application using GraalVM (and the SubstrateVM) that uses Hibernate?

What does Quarkus actually do to enable/support Hibernate?

Is Hibernate ORM compatible with GraalVM native image compilation?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

根据文档，GraalVM项目中的本机映像编译器对动态代理有一些限制。由于Hibernate广泛使用代理，它能在提前编译的项目中正常工作吗？项目似乎表明它可以，但我的理解主要是基于的一句话。Hibernate ORM现在即使编译为GraalVM本地映像也可以工作--只需确保使用Quarkus构建应用程序。如果我不想(或者...

问Hibernate ORM与GraalVM本地映像编译兼容吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Hibernate ORM与GraalVM本地映像编译兼容吗？EN