This looks like it could be a good case for some AOP. First start by creating a custom field annotation @CustomSequenceGeneratedValue, and then annotate the field on the entity with it:

public class MyEntity { ... @CustomSequenceGeneratedValue private Long generatedValue; public void setGeneratedValue(long generatedValue) { } } 

Then an aspect is created to increment generated values:

@Aspect public class CustomSequenceGeneratedValueAspect { @PersistenceContext private EntityManager em; @Before("execution(* com.yourpackage.dao.SomeDao.*.*(..))") public void beforeSaving(JoinPoint jp) throws Throwable { Object[] args = jp.getArgs(); MethodSignature ms = (MethodSignature) jp.getSignature(); Method m = ms.getMethod(); Annotation[][] parameterAnnotations = m.getParameterAnnotations(); for (int i = 0; i < parameterAnnotations.length; i++) { Annotation[] annotations = parameterAnnotations[i]; for (Annotation annotation : annotations) { if (annotation.annotationType() == CustomSequenceGeneratedEntity.class) { ... find generated properties run query and call setter ... ... Query query = em.createNativeQuery("select MY_SEQUENCE.NEXTVAL from dual"); } } } } } 

Then the aspect is scanned with <aop:aspectj-autoproxy />, and applied to any Spring DAO saving entities of this type. The aspect would populate the sequence generated values based on a sequence, in a transparent way for the user.

You mentioned being open to using JDBC. Here is how you can you use Entity Callback with JdbcTemplate, the example uses Postgres's syntax for selecting next value in a sequence, just update it to use the right syntax for your DB.

Add this to your entity class:

@javax.persistence.EntityListeners(com.example.MyEntityListener.class) 

And here is listener implementation (@Qualifier and required = true are necessary for it to work):

package com.example; import javax.persistence.PostPersist; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; import org.springframework.transaction.annotation.Transactional; @Component public class MyEntityListener { private static JdbcTemplate jdbcTemplate; @Autowired(required = true) @Qualifier("jdbcTemplate") public void setJdbcTemplate(JdbcTemplate bean) { jdbcTemplate = bean; } @PostPersist @Transactional public void postPersis(MyEntity entity) { if(isUpdateNeeded(entity)) { entity.setMyField(jdbcTemplate.queryForObject("select nextval('not_hibernate_sequence')", Long.class)); } } private boolean isUpdateNeeded(MyEntity entity) { // TODO - implement logic to determine whether to do an update return false; } } 

The hacky solution I used to keep it simple is the following:

MyEntity myEntity = new MyEntity(); myEntity.setDescription("blabla"); em.persist(myEntity); em.flush(myEntity); myEntity.setNewField(getFooSequence()); 

The complete code ("pseudo-code", I've written it directly on SO so it could have typos) with transaction handling would be like :

Entity

@Entity @Table(name="MyTable") public class MyEntity implements Serializable { @Id @SequenceGenerator(name="seq_id", sequenceName="seq_id", allocationSize=1) @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="seq_id") private Long id; private Long newField; // the optional sequence private String description /* Getters and Setters */ } 

Main EJB:

@Stateless @TransactionManagement(TransactionManagementType.CONTAINER) // default public class MainEjb implements MainEjbLocalInterface { @Inject DaoEjbLocalInterface dao; // Create new session, no OSIV here @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW) public Long insertMyEntity(boolean myCondition) throws Exception { try { MyEntity myEntity = dao.insertMyEntity(); // if this break, no FooSequence will be generated doOtherStuff(); // Do other non-database stuff that can break here. // If they break, no FooSequence will be generated, // and no myEntity will be persisted. if (myCondition) { myEntity.setNewField(dao.getFooSequence()); // This can't break (it would have break before). // But even if it breaks, no FooSequence will be generated, // and no myEntity will be persisted. } } catch (Exception e){ getContext().setRollbackOnly(); log.error(e.getMessage(),e); throw new MyException(e); } } } 

DAO EJB

@Stateless @TransactionManagement(TransactionManagementType.CONTAINER) // default public class DaoEjb implements DaoEjbLocalInterface { @PersistenceContext( unitName="myPersistenceUnit") EntityManager em; // default, use caller (MainEJB) session @TransactionAttribute(TransactionAttributeType.REQUIRED) public MyEntity insertMyEntity() throws Exception{ MyEntity myEntity = new MyEntity(); myEntity.setDescription("blabla"); em.persist(myEntity); em.flush(); // here it will break in case of database errors, // eg. description value too long for the column. // Not yet committed, but already "tested". return myEntity; } // default, use caller (MainEJB) session @TransactionAttribute(TransactionAttributeType.REQUIRED) public Long getFooSequence() throws Exception { Query query = em.createNativeQuery("SELECT nextval('seq_foo')"); return ((BigInteger) query.getResultList().get(0)).longValue(); } } 

This will guarantee there will be no gaps in the FooSequence generation.

The only drawback, that I don't care at all in my use case, is that FooSequence and the @Id sequence are not synchronized, so two concurrent inserts may have "inverted" FooSequence values, respecto to their order of arrive, eg.

ID NEW FIELD ------------- 1 2 2 1