The solution is simple, just use the CascadeType.MERGE instead of CascadeType.PERSIST or CascadeType.ALL. I have had the same problem and CascadeType.MERGE has worked for me. I hope you are sorted.
First remove all of your configuration Spring Boot will start it for you. Make sure you have an application.properties in your classpath and add the following properties. spring.datasource.url=jdbc:postgresql://localhost:5432/teste?charSet=LATIN1 spring.datasource.username=klebermo spring.datasource.password=123 spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect spring.jpa.show-sql=false spring.jpa.hibernate.ddl-auto=create If you really need access to a SessionFactory and that is basically for the same datasource, then you can do the following … Read more
@Transient complies with your needs.
Java’s transient keyword is used to denote that a field is not to be serialized, whereas JPA’s @Transient annotation is used to indicate that a field is not to be persisted in the database, i.e. their semantics are different.
Read this very nice article on the subject: Don’t Let Hibernate Steal Your Identity. The conclusion of the article goes like this: Object identity is deceptively hard to implement correctly when objects are persisted to a database. However, the problems stem entirely from allowing objects to exist without an id before they are saved. We … Read more
The JPA 2.0 Specification states that: The entity class must have a no-arg constructor. It may have other constructors as well. The no-arg constructor must be public or protected. The entity class must a be top-level class. An enum or interface must not be designated as an entity. The entity class must not be final. … Read more
I think a newer version of hibernate (supporting JPA 2.0) should handle this. But otherwise you can work it around by annotating the collection fields with: @LazyCollection(LazyCollectionOption.FALSE) Remember to remove the fetchType attribute from the @*ToMany annotation. But note that in most cases a Set<Child> is more appropriate than List<Child>, so unless you really need … Read more
The annotation @JoinColumn indicates that this entity is the owner of the relationship (that is: the corresponding table has a column with a foreign key to the referenced table), whereas the attribute mappedBy indicates that the entity in this side is the inverse of the relationship, and the owner resides in the “other” entity. This … Read more
As you state 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 … Read more
Sometimes you have two entities and there’s a relationship between them. For example, you might have an entity called University and another entity called Student and a University might have many Students: The University entity might have some basic properties such as id, name, address, etc. as well as a collection property called students that … Read more