JPA 2.0 persisting property with no setter

I'm using JPA 2.0, more precisely Eclipselink. Here's my problem:

I have an entity that has a property like "isPaid". that property is the result of some calculations the entity performs with some of its other fields. since this is derived from other fields, the property does not have a setter method.

As an example, the getter is something like this:

public bo开发者_C百科olean isPaid() {
  return this.totalAmount - this.amountPaid == 0;
}

that's just an example. The thing is, I want this property to be calculated and persisted, so i can do a jpql query like:

SELECT d FROM Debt d WHERE d.isPaid = true

Is this possible? Is there any workaround for this?.

I don't want to retrieve all entities to call this method and then filter those that return true.

Here are a couple of options:

1) Create a jpql query that directly does what you need:

select d from Debt d where (d.totalAmount - d.amountPaid) = 0

The benefits of the approach is that it is simple and will always work. The downside is that your query has to understand how the paid logic was calculated.

2) Create a persisted paid value that stores the calculated value:

@Basic
private boolean paid;

public boolean isPaid() {
    return this.paid;
}

private void updateCalculations() {
    this.paid =  (this.totalAmount - this.amountPaid == 0);
}

// using int as example here
public void setTotalAmount(int totalAmount) {
    this.totalAmount = totalAmount;
    updateCalculations();
}
public void setAmountPaid(int amountPaid) {
    this.amountPaid = amountPaid;
    updateCalculations();
}

The benefit of this approach is that you will be able to create a jpql query that directly checks for the boolean value, i.e.,

select d from Debt d where d.paid = true;

Obviously, the downside to the approach is that you need to make sure to recalculate the value anytime you update the values. However, this can be alleviated if you only calculate it on access. Meaning that in your isPaid() method, you calculate the value, assign it to the paid attribute and then return the value. If you decide to go with this approach, you will need to add a @PrePersist and @PreUpdate method that performs the paid calculation and updates the paid attribute prior to the bean being persisted to the datastore (makes sure that the paid value is always covered.

If you use JPA annotations on your attributes themselves, you can have a getter without a setter and still be able to correctly retrieve and store the values in the database.

Seen this: Mapping calculated properties with JPA ?

Basically you need a setter one way or the other in order to make JPA happy.