Hibernate 官方网站说，有native Hibernate API和 Hibernate 的JPA实现。在这两者之间有什么区别呢？优势劣势都是什么？
Hibernate website says there is a native Hibernate API as well as an implementation of JPA. What is the difference between the Native API and JPA implementation? Advantages, disadvantages?
在使用Spring MVC构建应用程序的时候，使用tomcat做为服务器，使用mysql作为持久化数据库，对spring来说，我是新手，并且没有使用过Hibernate,我的团队想通过使用ORM方案，并且比较来说，Hibernate比较流行。现在不确定，Hibernate 是如何工作的？或者，我该使用native Hibernate或者是hibernate的JPA实现？应用程序是数据驱动的，实体和报表展示的。
I am working on a Spring MVC application, using Tomcat as the, and MySQL for persistence. I'm newer to Spring and never used Hibernate. My team would like to use an ORM and Hibernate seems to be the most popular. We're not sure how Hibernate is going to workout or whether we should use native or JPA api. The application will be data driven, data entry, reporting, etc.
我知道，使用JPA的话，对于程序切换到另一个JPA实现会比较容易，尽管我不知道这样做是否是需要的。
I've read that using JPA makes its easier to switch to another JPA implementation, although I don't know if that will be needed or not.
JPA是通过ORM访问关系数据库的一个标准，Hibernate是它的一个实现。当年想使用JPA的时候，你需要使用它的一个实现，hibernate是一个不错的选择，但是还有其它实现，比如EclipseLink。
JPA is a standard for accessing relational databases through an object oriented API. Hibernate is an implementation of this API. When you want to use JPA you need some vendor to implement it, Hibernate is a good choice but there are others like EclipseLink.
Hibernate 存在的时间比JPA要长久。陈旧的native API仍然存在，并且提供一些标准的JPA没有提供的功能，如果你需要使用这些的话你就选择native API,使用JPA的话，就是更多程序员了解它，并且也可以通过配置来使用这些特性。
Hibernate exists longer than JPA. The native, older API (which was a model for JPA) still exists, and sometimes it offers more possibilities than are exposed through JPA (e.g. orphan removal). If you need those you need to use the native API. Using JPA has other merits, most important (in my opinion) more developers that know it. And you still can use some Hibernate specifics through configuration.
大多数的使用native hibernate的体验都是陈旧的，像Hibernate 3,是JPA的发行前版本.如果你是刚开始，建议使用JPA开始，尽管native的也有很多好的使用原由。
Most tutorials that use Hibernate natively are quite old - as is Hibernate 3, a pre-JPA release. While there are good reasons to use it, they (IMO) typically don't apply to the general audience. So if you are just beginning to learn in this field I would suggest to start with JPA.
作为线下资源，这里并没有何时的话题，你需要借鉴官方文档作为一个开始，并且至少从Hibernate4开始体验。
As for recommendations on offsite resources: For good reasons they are not on topic here. But thecurrent official Hibernate documentation would be a good start, as would be to look for toturial for at least Hibernate 4.
If you are using the JPA’s standard specification implementation (Read : Introduction to JPA), then you would use EntityManagerFactory for opening the session. But, if you are using the hibernate implementation, you have hibernate specific SessionFactory for managing the sessions. Here there is lot of confusion between developers like which one is the best approach. Here, there is two opinions are popular:
如果你在使用标准的JPA实现的话，你可能会使用EntityManagerFactory来打开一个session,但是，如果你使用hibernate的实现的话，你使用hibernate的特定的SessionFactory来管理你的session,开发者在选择两者的时候有很多疑惑的，这里有两个主要观点：
- EntityManagerFactory is the standard implementation, it is the same across all the implementations. If we migrate our ORM for any other provider, there will not be any change in the approach for handling the transaction. In contrast, if you use hibernate’s session factory, it is tied to hibernate APIs and ca not migrate to new vendor easily.
1.使用EntityManager是一个标准实现，你可以在所有实现中通用。如果我们更换其他ORM框架，不存在任何困难，但是你使用hibernate的话，那就绑定了，不能轻易的转换到其它实现了。
2.One dis-advantage of using the standard implementation is that, it is not providing the advanced features. There is not much control provided in the EntityManager APIs. Whereas, hibernate’s SessionFactory has lot of advanced features which can not done in JPA. One such thing is retrieving the ID generator without closing the transaction, batch insert, etc.
使用这个的一个缺点就是她不能提供一些hibernate的一些特性，比如，使用回本儿的SessionFactory不关闭事务来获取ID等。
Looking into the above points, one has to decide which one is better. There is no hard rule, after all it depends on the developers requirement. Another suggestion is that, we can use entity manger and session factory together. In this approach, entity manage delegates session handling to the hibernate by invoking the unwrap method. Like this:
比较而言，没有绝对的谁好谁不好，需要自己定夺。毕竟需要根据开发环境选择的，一个建议就是我们使用entitymager和sessionfactory一起，这样的话，我们就能融合两者了。
可以通过如下方法切换：Session session = entityManager.unwrap(Session.class);
Using EntityManagerFactory approach allows us to use callback method annotations like @PrePersist, @PostPersist,@PreUpdate with no extra configuration. Using similar callbacks while usingSessionFactory will require extra efforts.
使用EntityManager可以让我们通过注解使用回调方法@PrePersist, @PostPersist,@PreUpdate而hibernate则需要额外的工作。