Develop Reference

JPA equivalents to Hibernate org.hibernate.criterion.Example?

I have an application that uses Hibernate. We are moving to JPA 2.1 standard.
There are a lot of usage of "org.hibernate.criterion.Example" with its (excludeProperty) feature. Is there any equivalent to "Hibernate Example" in JPA 2.1?
Thanks.

JPA doesn't offer this yet but there are some open source frameworks which allow you to query by-example:
a Spring Data custom implementation
jaxio

Hibernate or JPA annotations to use

I am using Hibernate in our projects and annotation based configuration for Hibernate Domain Pojo Objects. For Annotations based configuration we have two options
JPA based annotations using javax.persistence.*
Use Hibernate Native Annotations org.hibernate.annotations.*
Currently we use JPA based annotation configuration for our POJO files and Hibernate native API like SessionFactory, Session, etc to open session and perform DB operations.
I have these questions:
Is there any problem mixing both JPA annotations and use Hibernate
native API?
This link explains one such issue
(cascade-jpa-hibernate-annotation-common-mistake)
Please provide your expertise, which type of annotations to use
JPA
Hibernate native
Mix both of them?

Hibernate provides one of the JPA implementations. If you use purely JPA in your code, you are free to change to a different implementation if a requirement arises. For example, EclipseLink/TopLink and OpenJPA are implementations which may be required for a different customer. A comprehensive list of implementations is here.
If you are compelled to use any exotic features provided by hibernate which are not in JPA specification, you should go for hibernate specific APIs in your code base. A related discussion from hibernate forum here.

We mixed some of these annotations since with the version of hibernate we were working those days, some features were not available on the JPA spec at that time. For instance to store a boolean value as a 'Y' or 'N' on th DB you have hibernate types you can use. But no such feature was available with the JPA spec at that time. I do not know about the status now. Also for orphan removal also those days JPA did not have the feature, but now i belive they provide an attribute called orphanRemoval on your cascade options. Also you have certain features such as #BatchSize to increase fetching performance with respect to bags. I am unaware if such features are available on the JPA spec yet.
In my experience, mixing and matching plus points from both would be beneficial given that you have no need of switching from one ORM to another.

Difference between Hibernate and Hibernate JPA

I found a lot of similar questions
Difference between Hibernate library and Hibernate JPA library
What's the difference between JPA and Hibernate?
similarity and difference between jpa and hibernate
but no one answers my next question. What diference between classical hibernate approach using org.hibernate.SessionFactory and JPA javax.persistence.EntityManager implementation? I heard, that this JPA implementation uses org.hibernate.SessionFactory and works like wrapper, is it real?

Indeed.
JPA is simply an API that allows you to abstract from the used persistence layer. Hibernate provides an implementation of the EntityManager interface that acts as an adapter - it uses the same underlying methods as a hibernate SessionManager.
The idea is that you could, for example, switch your implementation to Eclipse Link and not have to change any of your source code.

JPA is just a specification, meaning there is no implementation. You can annotate your classes as much as you would like with JPA annotations, however without an implementation nothing will happen. Think of JPA as the guidelines that must be followed or an interface, while Hibernate's JPA implementation is code that meets the API as defined by the JPA specification and provides the under the hood functionality.
When you use Hibernate with JPA you are actually using the Hibernate JPA implementation. The benefit of this is that you can swap out Hibernate's implementation of JPA for another implementation of the JPA specification. When you use straight Hibernate you are locking into the implementation because other ORMs may use different methods/configurations and annotations, therefore you cannot just switch over to another ORM.

Here is the answer of you question
What diference between classical hibernate approach using
org.hibernate.SessionFactory and JPA javax.persistence.EntityManager
implementation?
org.hibernate.SessionFactory
if you change the undeline ORM to IBatis(for e.g) you need to change the code as well.
javax.persistence.EntityManager
if you change the undeline ORM to IBatis(for e.g) you dont need to change the code.

To your First question,
JPA is a Java API specification which describes the management of relational data in applications using Java Platform. where as Hibernate is a ORM (Object Relational Mapping) library which follows JPA specification.
You can think JPA as a set of Rules which is implemented by Hibernate.
And answer for your second question,
As JPA is just an abstracted persistence layer it requires implementation. and Hibernate implements EntityManager interface that uses hibernate SessionManager.
In this way, you are completely detached from the implementation way, means you can switch to any of Hibernate or OenJPA or any other whenever you want, no additional code changes required.

Keyword
JPA
Hibernate
Location
Described in javax.persistence package
Described in org.hibernate
Intent
It's only Java speicification
It's is an implementation of JPA.
Functionality
It describes the handling of relational data in Java applications
Hibernate is an Obejct relational mapping (ORM) tool that is used to save the Java objects in the relational database system
Standard API
It's a standard API that permits to perform database operations
It is used in mapping Java data types with SQL data types and database tables
CRUD action
To perform CRUD actions for instances of mapped entity classes, it uses EntityManager interface which is supplied by EntityManagerFactory
To perform CRUD actions for instances of mapped entity classes, it uses Session interface which is supplied by SessionFactory

XSD Schema - JAXB marshaling - Datastore(JPA/JDO) Roundtrip

I'm trying to find a way to accomplish a xsd schema to datastore roundtrip, with minimum effort.
I used jaxb to build my object model from schemas, now I would like to store these objects based on JPA (or JDO or something else?). Is it possible, to auto enhance the objects with the missing annotations based on the JAXB Annotations? Is it desirable?
Thanks

You have several options for this use case.
Option #1 - Hyperjaxb3
I have not used this myself, but Hyperjaxb3 is supposed to generate both JAXB and JPA annotations on the model:
http://confluence.highsource.org/display/HJ3/Home
Option #2 - Use Dali to map your POJOs to Database (JPA)
The Eclipse Dali tool provides tooling to easily map your POJOs to a relational database using JPA:
http://www.eclipse.org/webtools/dali/
Option #3 - Use EclipseLink
EclipseLink provides both JPA and JAXB implementations. The JAXB implementation (MOXy) contains extensions specifically for handling JPA entities:
http://wiki.eclipse.org/EclipseLink/Examples/MOXy/JPA

Use DataNucleus and you can persist via JDO or JPA and internally it uses JAXB.
http://www.datanucleus.org

I am confused of Hibernate?

I learnt JPA for ORM. Now I am asked to use Hibernate as my provider.
If I start with Hibernate it is going down in different concept.
Please say me How can I relate JPA and hibernate together.
JPA reduces my Java code into simple code for persisting Objects.
Now what does hibernate help JPA and what does it provide.
Anyone please explain in simple.

As Pascal answered here
JPA is just an API. To use JPA, you need an implementation of this API and such implementations are called persistence providers (EcliseLink, Hibernate, OpenJPA)

Hibernate is not another concept; it is just one of many JPA implementations. Another would be EclipseLink. If you and the implementations keep to the specification then switching the implementation is just a matter of changing a couple of lines in your persistence.xml (e.g. the <provider> tag and implementation specific properties). At least in theory...

JPA is an API specification for persisting objects. It defines a SQL like query language, and annotations for defining entities and relationships.
Hibernate is an implementation of JPA that has various extensions as well as a legacy API and query language. As long as you don't use any of the extensions of Hibernate and stick with the JPA API you can more or less treat it interchangeably with other JPA implementations such as OpenJPA, TopLink etc.