{@code Money} is mapped to two table columns, a text {@code currency} column that stores the + * currency code, and a numeric {@code amount} column that stores the amount. + * + *
The main purpose of this class is to normalize the amount loaded from the database. To support + * all currency types, the scale of the numeric column is set to 2. As a result, the {@link + * BigDecimal} instances obtained from query ResultSets all have their scale at 2. However, some + * currency types, e.g., JPY requires that the scale be zero. This class strips trailing zeros from + * each loaded BigDecimal, then calls the appropriate factory method for Money, which will adjust + * the scale appropriately. + * + *
Although {@link CompositeUserType} is likely to suffer breaking change in Hibernate 6, it is + * the only option. The suggested alternatives such as Hibernate component or Java Embeddable do not + * work in this case. Hibernate component (our previous solution that is replaced by this class) + * does not allow manipulation of the loaded amount objects. Java Embeddable is not applicable since + * we do not own the Joda money classes. + * + *
Usage: + * + *
{@code
+ * '@'Type(type = JodaMoneyType.TYPE_NAME)
+ * '@'Columns(
+ * columns = {
+ * '@'Column(name = "cost_amount"),
+ * '@'Column(name = "cost_currency")
+ * }
+ * )
+ * Money cost;
+ * }
+ */
+public class JodaMoneyType implements CompositeUserType {
+
+ public static final JodaMoneyType INSTANCE = new JodaMoneyType();
+
+ /** The name of this type registered with JPA. See the example in class doc. */
+ public static final String TYPE_NAME = "JodaMoney";
+
+ // JPA property names that can be used in JPQL queries.
+ private static final ImmutableList{@link Money} is a wrapper around {@link org.joda.money.BigMoney} which itself contains two - * fields: a {@link BigDecimal} {@code amount} and a {@link CurrencyUnit} {@code currency}. When we - * store an entity with a {@link Money} field, we would like to store it in two columns, for the - * amount and the currency separately, so that it is easily queryable. This requires that we make - * {@link Money} a nested embeddable object. - * - *
However becaues {@link Money} is not a class that we control, we cannot use annotation-based - * mapping. Therefore there is no {@code JodaMoneyConverter} class. Instead, we define the mapping - * in {@code META-INF/orm.xml}. - * - *
Also note that any entity that contains a {@link Money} should should implement a
- * {@link @PostLoad} callback that converts the amount in the {@link Money} to a scale that is
- * appropriate for the currency. This is espcially necessary for currencies like JPY where the scale
- * is 0, which is different from the default scale that {@link BigDecimal} is persisted in database.
- */
+/** Unit tests for embeddable {@link JodaMoneyType}. */
public class JodaMoneyConverterTest {
@RegisterExtension
@@ -70,7 +52,8 @@ public class JodaMoneyConverterTest {
@Test
void roundTripConversion() {
- Money money = Money.of(CurrencyUnit.USD, 100);
+ Money money = Money.of(CurrencyUnit.USD, 100.12);
+ assertThat(money.getAmount().scale()).isEqualTo(2);
TestEntity entity = new TestEntity(money);
insertInDb(entity);
List result =
@@ -83,15 +66,55 @@ public class JodaMoneyConverterTest {
"SELECT amount, currency FROM \"TestEntity\" WHERE name = 'id'")
.getResultList());
assertThat(result.size()).isEqualTo(1);
+ // The amount property, when loaded as a raw value, has the same scale as the table column,
+ // which is 2.
assertThat(Arrays.asList((Object[]) result.get(0)))
- .containsExactly(
- BigDecimal.valueOf(100).setScale(CurrencyUnit.USD.getDecimalPlaces()), "USD")
+ .containsExactly(BigDecimal.valueOf(100.12).setScale(2), "USD")
.inOrder();
TestEntity persisted =
jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
assertThat(persisted.money).isEqualTo(money);
}
+ @Test
+ void roundTripConversion_scale0() {
+ Money money = Money.ofMajor(CurrencyUnit.JPY, 100);
+ assertThat(money.getAmount().scale()).isEqualTo(0); // JPY's amount has scale at 0.
+ TestEntity entity = new TestEntity(money);
+ insertInDb(entity);
+ List result =
+ jpaTm()
+ .transact(
+ () ->
+ jpaTm()
+ .getEntityManager()
+ .createNativeQuery(
+ "SELECT amount, currency FROM \"TestEntity\" WHERE name = 'id'")
+ .getResultList());
+ assertThat(result.size()).isEqualTo(1);
+ /* The amount property, when loaded as a raw value, has the same scale as the table column,
+ which is 2. */
+ assertThat(Arrays.asList((Object[]) result.get(0)))
+ .containsExactly(BigDecimal.valueOf(100).setScale(2), "JPY")
+ .inOrder();
+
+ result =
+ jpaTm()
+ .transact(
+ () ->
+ jpaTm()
+ .getEntityManager()
+ .createQuery("SELECT money FROM TestEntity WHERE name" + " = 'id'")
+ .getResultList());
+
+ // When the money field is loaded as an embedded entity, it has the desired scale (0).
+ assertThat(result.get(0)).isEqualTo(money);
+
+ TestEntity persisted =
+ jpaTm().transact(() -> jpaTm().getEntityManager().find(TestEntity.class, "id"));
+ assertThat(persisted.money).isEqualTo(money);
+ }
+
@Test
void roundTripConversionWithComplexEntity() {
Money myMoney = Money.of(CurrencyUnit.USD, 100);
@@ -132,11 +155,6 @@ public class JodaMoneyConverterTest {
jpaTm().transact(() -> jpaTm().getEntityManager().find(ComplexTestEntity.class, "id"));
assertThat(result.size()).isEqualTo(1);
- // Note that the amount has two decimal places even though JPY is supposed to have scale 0.
- // This is due to the unfournate fact that we need to accommodate differet currencies stored
- // in the same table so that the scale has to be set to the largest (2). When a Money field is
- // persisted in an entity, the entity should always have a @PostLoad callback to convert the
- // Money to the correct scale.
assertThat(Arrays.asList((Object[]) result.get(0)))
.containsExactly(BigDecimal.valueOf(2000).setScale(2), "JPY")
.inOrder();
@@ -147,13 +165,15 @@ public class JodaMoneyConverterTest {
}
// Override entity name to exclude outer-class name in table name. Not necessary if class is not
- // inner class. The double quotes are added to conform to our schema generation convention.
- @Entity(name = "\"TestEntity\"")
+ // inner class.
+ @Entity(name = "TestEntity")
@EntityForTesting
public static class TestEntity extends ImmutableObject {
@Id String name = "id";
+ @Type(type = JodaMoneyType.TYPE_NAME)
+ @Columns(columns = {@Column(name = "amount"), @Column(name = "currency")})
Money money;
public TestEntity() {}
@@ -164,50 +184,26 @@ public class JodaMoneyConverterTest {
}
// See comments on the annotation for TestEntity above for reason.
- @Entity(name = "\"ComplexTestEntity\"")
+ @Entity(name = "ComplexTestEntity")
@EntityForTesting
// This entity is used to test column override for embedded fields and collections.
public static class ComplexTestEntity extends ImmutableObject {
- // After the entity is loaded from the database, go through the money map and make sure that
- // the scale is consistent with the currency. This is necessary for currency like JPY where
- // the scale is 0 but the amount is persisteted as BigDecimal with scale 2.
- @PostLoad
- void setCurrencyScale() {
- moneyMap
- .entrySet()
- .forEach(
- entry -> {
- Money money = entry.getValue();
- if (!money.toBigMoney().isCurrencyScale()) {
- CurrencyUnit currency = money.getCurrencyUnit();
- BigDecimal amount = money.getAmount().setScale(currency.getDecimalPlaces());
- entry.setValue(Money.of(currency, amount));
- }
- });
- }
-
@Id String name = "id";
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "MoneyMap", joinColumns = @JoinColumn(name = "entity_name"))
@MapKeyColumn(name = "map_key")
- @AttributeOverrides({
- @AttributeOverride(name = "value.money.amount", column = @Column(name = "map_amount")),
- @AttributeOverride(name = "value.money.currency", column = @Column(name = "map_currency"))
- })
+ @Type(type = JodaMoneyType.TYPE_NAME)
+ @Columns(columns = {@Column(name = "map_amount"), @Column(name = "map_currency")})
Map