Persistenza Joda-Money tramite hibernate

Question

C'è una libreria per JodaTime che è provides Hibernate persistence. Recentemente ho iniziato a cercare su Joda-Money e ho iniziato a vedere come persistere usando Hibernate e non vedo alcuna libreria.

Qualche suggerimento?

Answer 1

Va bene ho seguito il tuo consiglio e cucinato un tipo personalizzato prezzo, come definito nella Biblioteca Joda, come un popolo di riferimento può guardare in su here, l'uso qui e test per il tipo personalizzato here

Answer 2

Joda-Money è molto nuovo, quindi non sorprende che nessuno abbia già fornito una mappatura Hibernate.

Tuttavia, la scrittura di adattatori di tipo Hibernate personalizzati è piuttosto semplice. Se osservi la fonte degli adattatori JodaTime, vedrai che sono davvero semplici. Vedere lo docs per come scrivere il proprio.

Answer 3

Il progetto User Type include il supporto Joda Money.

Answer 4

Il progetto User Type fornisce supporto per joda-money 0.6 dalla versione 3.0.0. Si prega di notare, tuttavia, che ciò richiede Hibernate 4. Anche l'attuale versione joda-money è 0.8

Se vuoi usarlo con Hibernate 3 usa l'esempio in Sudarshan anwser (è bugged al momento della scrittura).

Answer 5

Poiché il collegamento all'esempio nella risposta di Sudarshan è interrotto, ecco un'implementazione di un semplice tipo di utente personalizzato per org.joda.money.BigMoney, che persiste in oggetti di denaro in due colonne importo e valuta) e un esempio di come utilizzarlo. Funziona allo stesso modo per org.joda.money.Money.

package test; 

import java.io.Serializable; 
import java.math.BigDecimal; 
import java.sql.PreparedStatement; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.util.Currency; 

import org.apache.commons.lang.ObjectUtils; 
import org.hibernate.HibernateException; 
import org.hibernate.engine.spi.SessionImplementor; 
import org.hibernate.type.StandardBasicTypes; 
import org.hibernate.type.Type; 
import org.hibernate.usertype.CompositeUserType; 
import org.joda.money.BigMoney; 
import org.joda.money.CurrencyUnit; 

public class MoneyUserType implements CompositeUserType 
{ 
    private static final String[] PROPERTY_NAMES = {"amount", "currencyUnit"}; 
    private static final Type[] PROPERTY_TYPES = {StandardBasicTypes.BIG_DECIMAL, StandardBasicTypes.CURRENCY}; 

    public MoneyUserType() 
    { 
     super(); 
    } 

    public Object assemble(final Serializable cached, final SessionImplementor session, final Object owner) 
    throws HibernateException 
    { 
     return cached; 
    } 

    public Serializable disassemble(final Object value, final SessionImplementor session) throws HibernateException 
    { 
     return (Serializable) value; 
    } 

    public String[] getPropertyNames() 
    { 
     return PROPERTY_NAMES.clone(); 
    } 

    public Type[] getPropertyTypes() 
    { 
     return PROPERTY_TYPES.clone(); 
    } 

    public Object getPropertyValue(final Object component, final int property) throws HibernateException 
    { 
     BigMoney money = (BigMoney) component; 
     return (property == 0) ? money.getAmount() : money.getCurrencyUnit().toCurrency(); 
    } 

    public Object nullSafeGet(final ResultSet rs, final String[] names, final SessionImplementor session, 
    final Object owner) throws HibernateException, SQLException 
    { 
     BigDecimal amount = StandardBasicTypes.BIG_DECIMAL.nullSafeGet(rs, names[0], session); 
     Currency currency = StandardBasicTypes.CURRENCY.nullSafeGet(rs, names[1], session); 
     return BigMoney.of(CurrencyUnit.of(currency), amount); 
    } 

    public void nullSafeSet(final PreparedStatement st, final Object value, final int index, 
    final SessionImplementor session) throws HibernateException, SQLException 
    { 
     BigMoney money = (BigMoney) value; 
     BigDecimal amount = (money == null) ? null : money.getAmount(); 
     Currency currency = (money == null) ? null : money.getCurrencyUnit().toCurrency(); 

     StandardBasicTypes.BIG_DECIMAL.nullSafeSet(st, amount, index, session); 
     StandardBasicTypes.CURRENCY.nullSafeSet(st, currency, index + 1, session); 
    } 

    public Object replace(final Object original, final Object target, final SessionImplementor session, 
    final Object owner) throws HibernateException 
    { 
     return deepCopy(original); 
    } 

    public void setPropertyValue(final Object component, final int property, final Object value) 
    throws HibernateException 
    { 
     throw new HibernateException("Money is immutable."); 
    } 

    public Object deepCopy(final Object value) throws HibernateException 
    { 
     return (value != null) ? BigMoney.of(((BigMoney) value).getCurrencyUnit(), 
     ((BigMoney) value).getAmount()) : null; 
    } 

    public boolean equals(final Object x, final Object y) throws HibernateException 
    { 
     return ObjectUtils.equals(x, y); 
    } 

    public int hashCode(final Object x) throws HibernateException 
    { 
     return ObjectUtils.hashCode(x); 
    } 

    public boolean isMutable() 
    { 
     return false; 
    } 

    public Class<?> returnedClass() 
    { 
     return BigMoney.class; 
    } 
} 

Usage:

@Type(type = "test.MoneyUserType") 
@Columns(columns = {@Column(name = "AMOUNT"), @Column(name = "CURRENCY")}) 
private BigMoney money; 

Answer 6

Based on http://jadira.sourceforge.net

Tipi denaro consistono tipicamente di una moneta e la quantità. Jadira consente di memorizzare solo l'importo nel database con la valuta configurata utilizzando un parametro. Ad esempio:

@Column 
@Type(type = "org.jadira.usertype.moneyandcurrency.joda.PersistentMoneyAmount", 
    parameters = {@org.hibernate.annotations.Parameter(name = "currencyCode", value = "USD")}) 
private Money money; 

Alternatively, with other types two columns to hold the amount an currency: 

@Columns(columns = { @Column(name = "MY_CURRENCY"), @Column(name = "MY_AMOUNT") }) 
@Type(type = "org.jadira.usertype.moneyandcurrency.joda.PersistentMoneyAmountAndCurrency") 
private Money money;