I am having trouble deleting orphan nodes using JPA with the following mapping

    @OneToMany (cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = &quot;owner&quot;)
    private List&lt;Bikes&gt; bikes;

I am having the issue of the orphaned roles hanging around the database.

I can use the annotation `org.hibernate.annotations.Cascade` Hibernate specific tag but obviously I don&#39;t want to tie my solution into a Hibernate implementation.


**EDIT**: It seems JPA 2.0 will include support for this.

JPA CascadeType.ALL does not delete orphans

I am rather new to JPA 2 and it&#39;s CriteriaBuilder / CriteriaQuery API:

[`CriteriaQuery` javadoc][1]

[`CriteriaQuery` in the Java EE 6 tutorial][2]


I would like to count the results of a CriteriaQuery without actually retrieving them. Is that possible, I did not find any such method, the only way would be to do this:

    CriteriaBuilder cb = entityManager.getCriteriaBuilder();

    CriteriaQuery&lt;MyEntity&gt; cq = cb
            .createQuery(MyEntityclass);

    // initialize predicates here

    return entityManager.createQuery(cq).getResultList().size();

And that can&#39;t be the proper way to do it...

Is there a solution?


  [1]: http://java.sun.com/javaee/6/docs/api/javax/persistence/criteria/CriteriaQuery.html
  [2]: http://java.sun.com/javaee/6/docs/tutorial/doc/gjivm.html

In JPA 2, using a CriteriaQuery, how to count results

I&#39;m using JPA 2.0/Hibernate validation to validate my models. I now have a situation where the combination of two fields has to be validated:


    public class MyModel {
        public Integer getValue1() {
            //...
        }
        public String getValue2() {
            //...
        }
    }

The model is *invalid* if both `getValue1()` and `getValue2()` are `null` and valid otherwise.

How can I perform this kind of validation with JPA 2.0/Hibernate? With a simple `@NotNull` annotation both getters must be non-null to pass validation.






How can I validate two or more fields in combination?

Say I have a *unidirectional* `@ManyToOne` relationship like the following:


    @Entity
    public class Parent implements Serializable {

        @Id
        @GeneratedValue
        private long id;
    }

    @Entity
    public class Child implements Serializable {

        @Id
        @GeneratedValue
        private long id;

        @ManyToOne
        @JoinColumn
        private Parent parent;  
    }


If I have a parent P and children C&lt;sub&gt;1&lt;/sub&gt;...C&lt;sub&gt;n&lt;/sub&gt; referencing back to P, is there a clean and pretty way in JPA to automatically remove the children C&lt;sub&gt;1&lt;/sub&gt;...C&lt;sub&gt;n&lt;/sub&gt; when P is removed (i.e. `entityManager.remove(P)`)? 

What I&#39;m looking for is a functionality similar to `ON DELETE CASCADE` in SQL.

JPA: unidirectional many-to-one and cascading delete

I am wondering if it is possible using annotations to persist the `attributes` map in the following class using JPA2

    public class Example {
        long id;
        // ....
        Map&lt;String, String&gt; attributes = new HashMap&lt;String, String&gt;();
        // ....
    }

As we already have a pre existing production database, so ideally the values of `attributes`  could map to the following existing table:

    create table example_attributes {
        example_id bigint,
        name varchar(100),
        value varchar(100));



Storing a Map&lt;String,String&gt; using JPA

I have a following problem with entity mapping in JPA. I have two entities, first one is Lookup and the second is Text which represents translations for entities. Now I need to bound Lookup to the Text but I don&#39;t want Text to have reference to Lookup. To make this more complicated, Text does not use its primary key in this relationship but a metacode defined in a  `TXTHEAD_CODE` column. 

`Lookup.java`

    @Entity
    @Table(name = &quot;DATREG&quot;)
    public class Lookup implements PersistableEntity {

        @Id
        @Column(name = &quot;DATREG_META_CODE&quot;)
        private String metaCode;
    
        @OneToMany
	    @JoinTable(name=&quot;TXT&quot;, 
				joinColumns=@JoinColumn(name=&quot;DATREG_META_CODE&quot;, referencedColumnName=&quot;TXTHEAD_CODE&quot;),
				inverseJoinColumns=@JoinColumn(name=&quot;DATREG_META_CODE&quot;))
	    private List&lt;Text&gt; text;

`Text.java`

    @Entity
    @Table(name = &quot;TXT&quot;)
    public class Text {
	
	    @Id
	    @Column(name = &quot;TXT_ID&quot;)
	    private Long id;
	
	    @Column(name = &quot;TXTHEAD_CODE&quot;)
	    private String code;


So I have tried this (and few other variations) but with no result. I also can&#39;t create join table in the DB and I don&#39;t want bound Lookup to my Text class. So can anyone please tell me if there is some other way?

How to define unidirectional OneToMany relationship in JPA

I am trying following hql query to execute

    SELECT count(*) 
      FROM BillDetails as bd
     WHERE bd.billProductSet.product.id = 1002
       AND bd.client.id                 = 1

But it is showing 

    org.hibernate.QueryException: illegal attempt to dereference collection 
    [billdetail0_.bill_no.billProductSet] with element property reference [product] 
    [select count(*) from iland.hbm.BillDetails as bd where bd.billProductSet.product.id=1001 and bd.client.id=1]
    	at org.hibernate.hql.ast.tree.DotNode$1.buildIllegalCollectionDereferenceException(DotNode.java:68)
    	at org.hibernate.hql.ast.tree.DotNode.checkLhsIsNotCollection(DotNode.java:558)



org.hibernate.QueryException: illegal attempt to dereference collection

My Java application is using JPA for object persistence. The business domain is very simple (just three classes are persistent, with 3-5 properties in each). Queries are simple as well. The question is which approach I should use: JPQL or Criteria API?

What to use: JPQL or Criteria API?

Which of the following collection types do you use in your JPA domain model and why:

 - `java.util.Collection`
 - `java.util.List`
 - `java.util.Set`

I was wondering whether there are some ground rules for this.

**UPDATE** I know the difference between a `Set` and a `List`. A `List` allows duplicates and has an order and a `Set` cannot contain duplicate elements and does not define order. I&#39;m asking this question in the context of JPA. If you strictly follow the definition, then you should always end up using the `Set` type, since your collection is stored in relational database, where you can&#39;t have duplicates and where you have define an order by yourself, i.e. the order in you Java `List` is not necessarily preserved in the DB.

For example, most of the time I&#39;m using the `List` type, not because it has an order or allows duplicates (which I can&#39;t have anyway), because some of the components in my component library require a list.


Which Java Type do you use for JPA collections and why?

I&#39;ve been trying to find a JPA Criteria API tutorial but haven&#39;t been much successful. Do you know about any for beginners? I&#39;d like to start using it in an Java5/Maven app to build complex search queries. 

JPA Criteria Tutorial

I have 3 entities with ManyToMany relationships:

**Role Entity:**

    @Entity
    public class Role {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer roleID;
        private String roleName;
        private String description;
    
        @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH}, fetch = FetchType.EAGER)
        @JoinTable(name = &quot;role_permission&quot;, joinColumns = {@JoinColumn(name = &quot;role_id&quot;)}, inverseJoinColumns = {@JoinColumn(name = &quot;permission_id&quot;)})
        private Set&lt;Permission&gt; permissions = new LinkedHashSet&lt;Permission&gt;();
    }

**Permission Entity:**

    @Entity
    public class Permission {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private int permissionID;
        private String permissionName;
        private String description;
    
        @ManyToMany(cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH}, fetch = FetchType.EAGER)
        @JoinTable(name = &quot;permission_functionality&quot;, joinColumns = {@JoinColumn(name = &quot;permission_id&quot;)}, inverseJoinColumns = {@JoinColumn(name = &quot;functionality_id&quot;)})
        private Set&lt;Functionality&gt; functionalities = new LinkedHashSet&lt;&gt;();
    }

**Functionality Entity:**

    @Entity
    public class Functionality {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        private String name;
    }


I did the following:

 1. I have created 3 functionalities:

        Functionality1, Functionality2, Functionality3
   
 2. Then created 2 permissions:

        Permission1 with Functionality1, Functionality2

        Permission2 with Functionality2, Functionality3

 3. Then created a role:

        Role1 with Permission1 and Permission2 

I am getting the following exception:

&gt; java.lang.IllegalStateException: Multiple representations of the same entity [com.persistence.entity.admin.Functionality#1] are being merged. Detached: [com.persistence.entity.admin.Functionality@4729256a]; Detached: [com.persistence.entity.admin.Functionality@56ed25db]


java.lang.IllegalStateException: Multiple representations of the same entity with @ManyToMany 3 entities

I am using JPA 2.0 and hibernate. I have a User class and a Group class as follows:

    public class User implements Serializable {
        @Id
        @Column(name=&quot;USER_ID&quot;)
        private String userId;
    
        @ManyToMany
        @JoinTable(name = &quot;USER_GROUP&quot;,
                   joinColumns = {
                       @JoinColumn(name = &quot;GROUP_ID&quot;)
                   },
                   inverseJoinColumns = {
                       @JoinColumn(name = &quot;USER_ID&quot;)
                   }
        )
        private Set&lt;Group&gt; groupList;
        
        //get set methods
    }

    public class Group
    {
        @Id
        @Column(name=&quot;GROUP_ID&quot;)
        private String groupId;
    
        @ManyToMany(mappedBy=&quot;groupList&quot;)
        private Set&lt;User&gt; memberList;
        //get set methods
    }

And then, I create a user and group and then assign the user to the group.

What I want to have is when I delete the group, the group will be deleted (of course) and all the user-group relationship that the group has will be automatically deleted from the USER_GROUP join table but the user itself is not deleted from the USER table.

With the code I have above, only the row in the GROUP table will be deleted when I delete a group and the user will still have an entry to the deleted group in the USER_GROUP join table.


If I put cascade in the User class like this:

    @ManyToMany(cascade=CascadeType.ALL)
    @JoinTable(name = &quot;USER_GROUP&quot;,
    joinColumns =
    {
        @JoinColumn(name = &quot;GROUP_ID&quot;)
    },
    inverseJoinColumns =
    {
        @JoinColumn(name = &quot;USER_ID&quot;)
    })
    private Set&lt;Group&gt; groupList;
When I delete the group, the user will be deleted as well!

Is there any way to achieve what I want?

JPA Hibernate many-to-many cascading

Consider the following JPQL query:

    SELECT foo FROM Foo foo
    INNER JOIN FETCH foo.bar bar
    WHERE bar.baz = :baz

I&#39;m trying to translate this into a Criteria query. This is as far as I have gotten:

    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery&lt;Foo&gt; cq = cb.createQuery(Foo.class);
    Root&lt;Foo&gt; r = cq.from(Foo.class);
    Fetch&lt;Foo, Bar&gt; fetch = r.fetch(Foo_.bar, JoinType.INNER);
    Join&lt;Foo, Bar&gt; join = r.join(Foo_.bar, JoinType.INNER);
    cq.where(cb.equal(join.get(Bar_.baz), value);

The obvious problem here is that I am doing the same join twice, because `Fetch&lt;Foo, Bar&gt;` doesn&#39;t seem to have a method to get a `Path`.
Is there any way to avoid having to join twice? Or do I have to stick with good old JPQL with a query as simple as that?

How to properly express JPQL &quot;join fetch&quot; with &quot;where&quot; clause as JPA 2 CriteriaQuery?

I just want to know what is the difference between all these annotations. Why are we using these... means they have no effect especially field level and property level.

And what is the purpose of using mixed level annotation like:

    @Entity
    @Access(AccessType.FIELD)
    class Employee {
        // why their is a field level access 
        private int id;
     
        // whats the purpose of transient here
        @Transient                               
        private String phnnumber;
     
        // why its a property level access
        @Access(AccessType.property)             
        public String getPhnnumber() {
            return &quot;1234556&quot;;
        }

    }


what exactly this class says?

What is the purpose of AccessType.FIELD, AccessType.PROPERTY and @Access

I have tried to write a query statement with a subquery and an `IN` expression for many times. But I have never succeeded.

I always get the exception, &quot; Syntax error near keyword &#39;IN&#39; &quot;, the query statement was build like this,

    SELECT t0.ID, t0.NAME
    FROM EMPLOYEE t0
    WHERE IN (SELECT ?
              FROM PROJECT t2, EMPLOYEE t1
              WHERE ((t2.NAME = ?) AND (t1.ID = t2.project)))

I know the word before &#39;IN&#39; lose.

Have you ever written such a query? Any suggestion?

JPA 2.0, Criteria API, Subqueries, In Expressions

Can you please help me how to convert the following codes to using &quot;in&quot; operator of criteria builder?
I need to filter by using list/array of usernames using &quot;in&quot;.

*I also tried to search using JPA CriteriaBuilder - &quot;in&quot; method but cannot find good result.
So I would really appreciate also if you can give me reference URLs for this topic. Thanks.*

Here is my codes:

    //usersList is a list of User that I need to put inside IN operator 
    
    CriteriaBuilder builder = getJpaTemplate().getEntityManagerFactory().getCriteriaBuilder();
    CriteriaQuery&lt;ScheduleRequest&gt; criteria = builder.createQuery(ScheduleRequest.class);
    
    Root&lt;ScheduleRequest&gt; scheduleRequest = criteria.from(ScheduleRequest.class);
    criteria = criteria.select(scheduleRequest);
    
    List&lt;Predicate&gt; params = new ArrayList&lt;Predicate&gt;();
    
    List&lt;ParameterExpression&lt;String&gt;&gt; usersIdsParamList = new ArrayList&lt;ParameterExpression&lt;String&gt;&gt;();
    
    for (int i = 0; i &lt; usersList.size(); i++) {
    ParameterExpression&lt;String&gt; usersIdsParam = builder.parameter(String.class);
    params.add(builder.equal(scheduleRequest.get(&quot;createdBy&quot;), usersIdsParam) );
    usersIdsParamList.add(usersIdsParam);
    }
    
    criteria = criteria.where(params.toArray(new Predicate[0]));
    
    TypedQuery&lt;ScheduleRequest&gt; query = getJpaTemplate().getEntityManagerFactory().createEntityManager().createQuery(criteria);
    
    for (int i = 0; i &lt; usersList.size(); i++) {
    query.setParameter(usersIdsParamList.get(i), usersList.get(i).getUsername());
    }
    
    List&lt;ScheduleRequest&gt; scheduleRequestList = query.getResultList();

The internal Query String is converted to below, so I don&#39;t get the records created by the two users, because it is using &quot;AND&quot;.

    select generatedAlias0 from ScheduleRequest as generatedAlias0 where ( generatedAlias0.createdBy=:param0 ) and ( generatedAlias0.createdBy=:param1 ) order by generatedAlias0.trackingId asc 

JPA CriteriaBuilder - How to use &quot;IN&quot; comparison operator

I have been using Hibernate Restrictions in JPA 1.0 ( Hibernate driver ). There is defined `Restrictions.ilike(&quot;column&quot;,&quot;keyword&quot;, MatchMode.ANYWHERE)` which tests if the keyword matching the column anywhere and it is case-insensitive. 

Now, I am using JPA 2.0 with EclipseLink as driver so I have to use &quot;Restrictions&quot; build-in JPA 2.0. I found `CriteriaBuilder` and method `like`, I have also found out how to make it matching anywhere ( although it is aweful and manual ), but still I haven&#39;t figured out how to do it case-insensitive.

There is my current aweful solution:

    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery&lt;User&gt; query = builder.createQuery(User.class);
    EntityType&lt;User&gt; type = em.getMetamodel().entity(User.class);
    Root&lt;User&gt; root = query.from(User.class);
   
    // Where   
    // important passage of code for question  
    query.where(builder.or(builder.like(root.get(type.getDeclaredSingularAttribute(&quot;username&quot;, String.class)), &quot;%&quot; + keyword + &quot;%&quot;),
            builder.like(root.get(type.getDeclaredSingularAttribute(&quot;firstname&quot;, String.class)), &quot;%&quot; + keyword + &quot;%&quot;),
            builder.like(root.get(type.getDeclaredSingularAttribute(&quot;lastname&quot;, String.class)), &quot;%&quot; + keyword + &quot;%&quot;)
            ));

    // Order By
    query.orderBy(builder.asc(root.get(&quot;lastname&quot;)),
                builder.asc(root.get(&quot;firstname&quot;)));

    // Execute
    return em.createQuery(query).
                setMaxResults(PAGE_SIZE + 1).
                setFirstResult((page - 1) * PAGE_SIZE).
                getResultList();

**Questions:**

Is there any function like in Hibernate driver? 

Am I using the JPA 2.0 criteria correctly? This is awkward and uncomfortable solution in compare to Hibernate Restrictions.

Or can anybody help me how to change my solution to be case-insensitive, please?

Thanks a lot.


JPA2: Case-insensitive like matching anywhere

Here is my JPA2 / Hibernate definition:

    Code:
    @Column(nullable = false)
    private boolean enabled;


In MySql this column is resolved to a bit(1) datatype - which does not work for me. For legacy issues I need to map the boolean to a tinyint not to a bit. But I do not see a possibility to change the default datatype. Is there any?

Hibernate JPA, MySQL and TinyInt(1) for Boolean instead of bit or char

Is it possible to select, say, only properties **A and B from an object using a `JPA` query** without using criteria queries?

To select all properties I&#39;d just do something like:

    SELECT i FROM ObjectName i WHERE i.id = 10

But I have an object with **many** properties on a legacy system, and want to select just a few even though I&#39;m aware selecting several properties is usually quick.

Is this possible without using criteria queries?

JPA Query selecting only specific columns without using Criteria Query?

*Using JPA 2 with EclipseLink implementation.*

I&#39;m trying to build a dynamic query which should bring me some records persisted after a given date.

    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery&lt;Event&gt; criteria = builder.createQuery(Event.class);
    Root&lt;Event&gt; root = criteria.from(Event.class);
    criteria.select(root);
    criteria.distinct(true);
    List&lt;Predicate&gt; predicates = new ArrayList&lt;Predicate&gt;();
    //...
    if (dateLimit != null){
        ParameterExpression&lt;Date&gt; param = builder.parameter(Date.class, &quot;dateLimit&quot;);
        predicates.add(builder.lessThanOrEqualTo(root.get(&quot;dateCreated&quot;), param));
    }

`lessThanOrEqualTo()` and `le()` are the only two methods in the API which look like may help me in this case. This warning is thrown by the eclipse though:

    Bound mismatch: The generic method lessThanOrEqualTo(Expression&lt;? extends Y&gt;, Expression&lt;? extends Y&gt;)
    of type CriteriaBuilder is not applicable for the arguments (Path&lt;Object&gt;, ParameterExpression&lt;Date&gt;).
    The inferred type Object is not a valid substitute for the bounded parameter
    &lt;Y extends Comparable&lt;? super Y&gt;&gt;

I can imagine that I&#39;m not taking the correct approach for this problem but I can&#39;t find anywhere some tips or pointers for a possible solution.


Compare Date entities in JPA Criteria API

I&#39;m using Spring Boot 1.2.5 with JPA2 to annotate entities (and hibernate as underlaying JPA implementation).

I wanted to use second level cache in that setup, so entities were annotated with `@javax.persistence.Cacheable`

I also added following in application.properties:

    spring.jpa.properties.hibernate.cache.use_second_level_cache=true
    spring.jpa.properties.hibernate.cache.use_query_cache=true
    spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

During bootup hibernate complained about lack of `EhCacheRegionFactory` so I also added this to pom:

    &lt;dependency&gt;
        &lt;groupId&gt;org.hibernate&lt;/groupId&gt;
        &lt;artifactId&gt;hibernate-ehcache&lt;/artifactId&gt;
    &lt;/dependency&gt;

But still queries like `entityManager.find(Clazz.class, pk)` are firing DB query instead of using cached data.

Any idea what is missing?

Spring Boot + JPA2 + Hibernate - enable second level cache

I&#39;m trying to use Criteria API in my new project:

    public List&lt;Employee&gt; findEmps(String name) {
		CriteriaBuilder cb = em.getCriteriaBuilder();
		CriteriaQuery&lt;Employee&gt; c = cb.createQuery(Employee.class);
		Root&lt;Employee&gt; emp = c.from(Employee.class);
		c.select(emp);
		c.distinct(emp);
		List&lt;Predicate&gt; criteria = new ArrayList&lt;Predicate&gt;();
		
		if (name != null) {
			ParameterExpression&lt;String&gt; p = cb.parameter(String.class, &quot;name&quot;);
			criteria.add(cb.equal(emp.get(&quot;name&quot;), p));
		}

		/* ... */
		
		if (criteria.size() == 0) {
			throw new RuntimeException(&quot;no criteria&quot;);
		} else if (criteria.size() == 1) {
			c.where(criteria.get(0));
		} else {
			c.where(cb.and(criteria.toArray(new Predicate[0])));
		}
		
		TypedQuery&lt;Employee&gt; q = em.createQuery(c);
		
		if (name != null) {
			q.setParameter(&quot;name&quot;, name);
		}
		
		/* ... */
		
		return q.getResultList();
	}

Now when I change this line:

    			criteria.add(cb.equal(emp.get(&quot;name&quot;), p));
to:

    			criteria.add(cb.like(emp.get(&quot;name&quot;), p));

I get an error saying: 

&gt; The method like(Expression&lt;String&gt;, Expression&lt;String&gt;) in the type CriteriaBuilder is not &gt; applicable for the arguments (Path&lt;Object&gt;, ParameterExpression&lt;String&gt;)

What&#39;s the problem?


JPA/Criteria API - Like &amp; equal problem

This post is in continuation of https://stackoverflow.com/questions/17856917/jpa-how-to-get-the-value-from-database-after-persist

When I execute the following I am getting following exception, how can I resolve this?

    Not allowed to create transaction on shared EntityManager - use Spring 
    transactions or EJB CMT

 **DAOImpl** code

    public void create(Project project) {
            entityManager.persist(project);
            entityManager.getTransaction().commit();
            project = entityManager.find(Project.class, project.getProjectId());
            entityManager.refresh(project);
            System.out.println(&quot;Id    -- &quot; + project.getProjectId());
                System.out.println(&quot;no -- &quot; + project.getProjectNo());
        }

**applicationContext.xml**

    &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot;
    	xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot; xmlns:tx=&quot;http://www.springframework.org/schema/tx&quot;
    	xmlns:context=&quot;http://www.springframework.org/schema/context&quot;
    	xsi:schemaLocation=&quot;http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd&quot;&gt;
    
    	&lt;bean id=&quot;DataSource&quot;
    		class=&quot;org.springframework.jdbc.datasource.DriverManagerDataSource&quot;&gt;
    		&lt;property name=&quot;username&quot; value=&quot;scott&quot; /&gt;
    		&lt;property name=&quot;password&quot; value=&quot;tiger&quot; /&gt;
    		&lt;property name=&quot;driverClassName&quot; value=&quot;oracle.jdbc.driver.OracleDriver&quot; /&gt;
    		&lt;property name=&quot;url&quot; value=&quot;jdbc:oracle:thin:@myserver:1521:ORCL&quot; /&gt;
    	&lt;/bean&gt;
    
    	&lt;bean id=&quot;entityManagerFactory&quot;
    		class=&quot;org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean&quot;&gt;
    		&lt;property name=&quot;dataSource&quot; ref=&quot;DataSource&quot; /&gt;
    		&lt;property name=&quot;packagesToScan&quot; value=&quot;test.entity&quot; /&gt;
    		&lt;property name=&quot;jpaVendorAdapter&quot;&gt;
    			&lt;bean class=&quot;org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter&quot;&gt;
    				&lt;property name=&quot;showSql&quot; value=&quot;true&quot; /&gt;
    				&lt;property name=&quot;generateDdl&quot; value=&quot;false&quot; /&gt;
    				&lt;property name=&quot;databasePlatform&quot; value=&quot;org.hibernate.dialect.Oracle10gDialect&quot; /&gt;
    			&lt;/bean&gt;
    		&lt;/property&gt;
    	&lt;/bean&gt;
    
    	&lt;context:component-scan base-package=&quot;test.net&quot; /&gt;
                   
        &lt;tx:annotation-driven transaction-manager=&quot;transactionManager&quot;/&gt; 
        
         &lt;bean id=&quot;transactionManager&quot; class=&quot;org.springframework.orm.jpa.JpaTransactionManager&quot;&gt;
            &lt;property name=&quot;entityManagerFactory&quot; ref=&quot;entityManagerFactory&quot; /&gt;
        &lt;/bean&gt;         
                               
         &lt;context:annotation-config/&gt;
    
    &lt;/beans&gt;

All Jpa 2.0 Solutions on Gang of Coders

Total of 23 Jpa 2.0 Solutions