We Keep Coding

Spring Boot Hibernate Combine Annotations into one

I basically would like to turn this:
#Entity
#Table(name = "edu_course")
public class EduCourse {
#Id
#GeneratedValue(strategy=GenerationType.SEQUENCE, generator="course_seq")
#SequenceGenerator(
name="course_seq",
sequenceName="course_sequence",
allocationSize=20
)
private int id;
}
into this:
#Entity
#Table(name = "edu_course")
public class EduCourse {
#SequenceId(name = "course")
private int id;
}
I tried different things but I always end up with the complier warning: "This annotation is not applicable to target 'annotation class'".
Is that somehow possible to do?

It is not possible to create meta-annotations in the current spec.
Take a look at #Id annotation:
#Target({METHOD, FIELD})
#Retention(RUNTIME)
public #interface Id {}
ANNOTATION_TYPE is not listed as a possible target, which is why you receive "This annotation is not applicable to target 'annotation class'" error.
There is an open issue Allow type level annotations to be used as meta-annotations #43 created in 2013, sadly it is still not implemented in 2023.

Using javax #Transient annotation with a field of MappedSuperclass

Javax's #Transient annotation when applied over an #Entity class' field will prevent the annotated field from being persisted into the database as a column. Is there a method to selectively achieve this behavior (of excluding the persistence of a certain column) for a field in a MappedSuperclass?
To clarify, I want some field x present in a MappedSuperclass to be persisted for some entity classes that extend the MappedSuperclass and excluded from persistence in some other extending entity classes.
I have tried shadowing the field x in the extending class and annotating it with #Transient, however, this doesn't seem to work. Is there any alternative approach that would enable this behavior?

Yes. In the children entity class that extends #MappedSuperclass , you can configure it to use the property access for this transient field .
So assuming a given #MappedSuperclass has a #Transient field :
#MappedSuperclass
public abstract class Parent {
#Transient
protected LocalDateTime createdTs;
}
For the children entity that want to include this transient field , you could do :
#Entity
#Table(name = "foo")
public class Foo extends Parent {
#Id
private Long id;
#Access(AccessType.PROPERTY)
#Column(name= "createTs")
public LocalDateTime getCreatedTs() {
return this.createdTs;
}
}
And for the children entity that want to exclude this transient field , you could do :
#Entity
#Table(name = "foo")
public class Foo extends Parent {
#Id
private Long id;
}

QueryDsl #QueryType value for ListPath?

I want to use querydsl auto generation of an #Entity to a querydsl mapping class.
Problem: I have a #Transient field that I have to qualify with #QueryType in order to make querydsl pick it up for generation.
My goal is to generate a ListPath<String, StringPath>, but the #QueryType annotation is missing any list value type:
#Entity
public class MyDto {
public List myList;
#Transient
#QueryType(value = ???)
public List<String> myTransientList;
}
The first list is generated properly to public final ListPath<String, StringPath> myList.
But how can I also include the 2nd list?

Hibernate #Transient MappingException

I am trying to add a Transient property to my Embeddable class. Here is what I have:
#NoArgsConstructor
#AllArgsConstructor
#Data
#Builder
#Embeddable
public class PackageProduct
{
#Field
private String productId;
#Transient
private Product product;
}
And PackageProduct is used in Package.java like this;
#ElementCollection(targetClass=PackageProduct.class, fetch = FetchType.EAGER)
private Set<PackageProduct> packageProducts;
However, this throws the following exception:
Caused by: org.hibernate.MappingException: Could not determine type for: *.*.*.Product, at table: Package_packageProducts, for columns: [org.hibernate.mapping.Column(packageProducts.product)]
The exception is no longer thrown if I annotate my PackageProduct class with this:
#Access(AccessType.FIELD)
I am trying to understand why it works with the class level #Access annotation. Any help is appreciated. Thanks.

In hibernate either you can apply all annotations on fields or methods, simultaneously mix use is not allow.To override this #Access is needed.In your product class if you are using such case, rectify this.

Logical delete at a common place in hibernate

I am using Spring and Hibernate for my application.
I am only allowing logical delete in my application where I need to set the field isActive=false. Instead of repeating the same field in all the entities, I created a Base Class with the property and getter-setter for 'isActive'.
So, during delete, I invoke the update() method and set the isActive to false.
I am not able to get this working. If any one has any idea, please let me know.
Base Entity
public abstract class BaseEntity<TId extends Serializable> implements IEntity<TId> {
#Basic
#Column(name = "IsActive")
protected boolean isActive;
public Boolean getIsActive() {
return isActive;
}
public void setIsActive(Boolean isActive) {
isActive= isActive;
}
}
Child Entity
#Entity(name="Role")
#Table(schema = "dbo")
public class MyEntity extends BaseEntity {
//remaining entities
}
Hibernate Util Class
public void remove(TEntity entity) {
//Note: Enterprise data should be never removed.
entity.setIsActive(false);
sessionFactory.getCurrentSession().update(entity);
}

Try to replace the code in setIsActive method with:
public void setIsActive(Boolean isActive) {
this.isActive = isActive;
}
in your code the use of variable name without this could be ambiguos...
I think you should also add #MappedSuperclass annotation to your abstract class to achieve field inheritance.

The issue with the proposed solution (which you allude to in your comment to that answer) is that does not handle cascading delete.
An alternative (Hibernate specific, non-JPA) solution might be to use Hibernate's #SQLDelete annotation:
http://docs.jboss.org/hibernate/orm/3.6/reference/en-US/html/querysql.html#querysql-cud
I seem to recall however that this Annotation cannot be defined on the Superclass and must be defined on each Entity class.
The problem with Logical delete in general however is that you then have to remember to filter every single query and every single collection mapping to exclude these records.
In my opinion an even better solution is to forget about logical delete altogether. Use Hibernate Envers as an auditing mechanism. You can then recover any deleted records as required.
http://envers.jboss.org/

You can use the SQLDelete annotation...
#org.hibernate.annotations.SQLDelete;
//Package name...
//Imports...
#Entity
#Table(name = "CUSTOMER")
//Override the default Hibernation delete and set the deleted flag rather than deleting the record from the db.
#SQLDelete(sql="UPDATE customer SET deleted = '1' WHERE id = ?")
//Filter added to retrieve only records that have not been soft deleted.
#Where(clause="deleted <> '1'")
public class Customer implements java.io.Serializable {
private long id;
...
private char deleted;
Source: http://featurenotbug.com/2009/07/soft-deletes-using-hibernate-annotations/