public  void afterPropertiesSet() 
{
		EntityManagerFactory emf = getEntityManagerFactory();
		if (emf == null && getEntityManager() == null) {
			throw new IllegalArgumentException("entityManagerFactory or entityManager is required");
		}
		if (emf instanceof EntityManagerFactoryInfo) {
			JpaDialect jpaDialect = ((EntityManagerFactoryInfo) emf).getJpaDialect();
			if (jpaDialect != null) {
				setJpaDialect(jpaDialect);
			}
		}
}

Eagerly initialize the JPA dialect, creating a default one for the specified EntityManagerFactory if none set.

 protected  void flushIfNecessary(EntityManager em,
    boolean existingTransaction) throws PersistenceException 
{
		if (isFlushEager()) {
			logger.debug("Eagerly flushing JPA entity manager");
			em.flush();
		}
}

Flush the given JPA entity manager if necessary.

 public EntityManager getEntityManager() 
{
		return entityManager;
}

Return the JPA EntityManager to use.

 public JpaDialect getJpaDialect() 
{
		return this.jpaDialect;
}

Return the JPA dialect to use for this accessor.

Creates a default one for the specified EntityManagerFactory if none set.

 public boolean isFlushEager() 
{
		return this.flushEager;
}

Return if this accessor should flush changes to the database eagerly.

 public  void setEntityManager(EntityManager entityManager) 
{
	      	 
		this.entityManager = entityManager;
}

Set the JPA EntityManager to use.

 public  void setFlushEager(boolean flushEager) 
{
		this.flushEager = flushEager;
}

Set if this accessor should flush changes to the database eagerly.

Eager flushing leads to immediate synchronization with the database, even if in a transaction. This causes inconsistencies to show up and throw a respective exception immediately, and JDBC access code that participates in the same transaction will see the changes as the database is already aware of them then. But the drawbacks are:

• additional communication roundtrips with the database, instead of a single batch at transaction commit;
• the fact that an actual database rollback is needed if the JPA transaction rolls back (due to already submitted SQL statements).

 public  void setJpaDialect(JpaDialect jpaDialect) 
{
		this.jpaDialect = (jpaDialect != null ? jpaDialect : new DefaultJpaDialect());
}

Set the JPA dialect to use for this accessor.

The dialect object can be used to retrieve the underlying JDBC connection, for example.

 public RuntimeException translateIfNecessary(RuntimeException ex) 
{
		return DataAccessUtils.translateIfNecessary(ex, getJpaDialect());
}

Convert the given runtime exception to an appropriate exception from the org.springframework.dao hierarchy if necessary, or return the exception itself if it is not persistence related

Default implementation delegates to the JpaDialect. May be overridden in subclasses.