Spring - No EntityManager with actual transaction available for current thread - cannot reliably process 'persist' call

I had the same error because I switched from XML- to java-configuration.

The point was, I didn't migrate `<tx:annotation-driven/>` tag, as Stone Feng suggested.

So I just added `@EnableTransactionManagement` as suggested here

[To see links please register here]

, and it works now

I had the same problem and I added `tx:annotation-driven` in `applicationContext.xml` and it worked.

This helped us, maybe it can help others in the future. `@Transaction` was not working for us, but this did:

`@ConditionalOnMissingClass("org.springframework.orm.jpa.JpaTransactionManager")`

Adding the `org.springframework.transaction.annotation.Transactional` annotation at the class level for the test class fixed the issue for me.

Just a note for *other* users searching for answers for thie error. Another common issue is:

> You generally cannot call an `@transactional` method from within the same class.

*(There are ways and means using AspectJ but refactoring will be way easier)*

So you'll need a calling class and class that holds the `@transactional` methods.

If you have

@Transactional // Spring Transactional
class MyDao extends Dao {
}

and super-class

class Dao {
public void save(Entity entity) { getEntityManager().merge(entity); }
}

and you call

@Autowired MyDao myDao;
myDao.save(entity);

you won't get a Spring TransactionInterceptor (that gives you a transaction).

This is what you need to do:

@Transactional
class MyDao extends Dao {
public void save(Entity entity) { super.save(entity); }
}

Unbelievable but true.

I got the same error when I executed the Spring JPA ```deleteAll()``` method from Junit test cases. I simply used the ```deleteInBatch()``` & ```deleteAllInBatch()``` and its perfectly works. We do not need to mark ```@Transactional``` at the test cases level.

For anyone with the same issue as I had, I was calling a public method `method1` from within another class.
`method1` then called another public method `method2` within the same class.
`method2` was annotated with `@Transactional`, but `method1` was not.
All that `method1` did was transform some arguments and directly call `method2`, so no DB operations here.

The issue got solved for me once I moved the `@Transactional` annotation to `method1`.

Not sure the reason for this, but this did it for me.

Without @Transactional annotation you can achieve the same goal with finding the entity from the DB and then removing that entity you got from the DB.

CrudRepositor -> void delete(T var1);

Calling the repository method was being called within a class with @Component, taking that method out of that class and placing it inside another with @Service worked.