Dúvida sobre persistência de objetos de uma classe Moeda

Este é um ótimo exemplo para demonstrar que um value object possui comportamentos (operações de negócio). Este pattern é confundido com o DTO.

JavaTeenager Membro desde: 16/05/2005 08:47:08 Mensagens: 152 Offline

Neste caso é iteressante armazenar o simbolo monetário u alguma informação dizendo qual a moeda utilizada ?
Como vocês fazem isto ?
Nunca trabalhei em um projeto que necessitasse disto.

Se você for trabalhar com moedas diferentes é necessário sim você dizer qual a moeda que vai usar. Eu pensei em um atributo do tipo java.util.Currency, como falei antes, mas não sei se seria viável ou como ele seria armazenado no banco.

Galera vcs que trabalham com BigDecimal, um colega meu disse que o ejb nao dava "mapeamento" para BigDecimal e sim apenas para Double, ainda é assim ou ja tem suporte para BigDecimal tbem ? senão so da pra usar Double mesmo é isso ?

Se você for trabalhar com moedas diferentes é necessário sim você dizer qual a moeda que vai usar. Eu pensei em um atributo do tipo java.util.Currency, como falei antes, mas não sei se seria viável ou como ele seria armazenado no banco.

Geralmente eu uso um código + ou - assim(pego em koders.com):

import java.math.BigDecimal;

/**
 * Object to store and manipulate money.
 */
public class Currency extends BigDecimal {
    /**
     * Construct a Currency object of value zero.
     */
    public Currency() {
        super(0);
    }

/**
     * Construct a Currency object from a BigDecimal or Currency object.
     * A null value result in an object containing zero.
     */
    public Currency(BigDecimal value) {
        super((value == null) ? 0.0 : value.doubleValue());
    }
 
    /**
     * Construct a Currency object from a double.
     */
    public Currency(double value) {
        super(value);
    }
 
    /**
     * Construct a Currency object from a float.
     */
    public Currency(float value) {
        super((double)value);
    }
 
    /**
     * Construct a Currency object from a String.
     */
    public Currency(String value) {
        this(Double.valueOf(value).doubleValue());
    }

/**
     * Check if equal to a float value.
     */
    public boolean equals(float value) {
        return compareTo(new Currency(value)) == 0;
    }

/**
     * Check if equal to a double value.
     */
    public boolean equals(double value) {
        return compareTo(new Currency(value)) == 0;
    }

/**
     * Returns a Currency whose value is (this + val).
     */
    public Currency add(Currency val) {
        return new Currency(super.add(val));
    }

/**
     * Returns a Currency whose value is (this - val).
     */
    public Currency subtract(Currency val) {
        return new Currency(super.subtract(val));
    }

/**
     * Returns a Currency whose value is (this * val)
     */
    public Currency multiply(Currency val){
        return new Currency(super.multiply(val));
    }
            
    /**
     * Returns a Currency whose value is (this * val)
     */
    public Currency multiply(int val){
        return multiply(new Currency(val));
    }
            
    /**
     * Returns a Currency whose value is (this / val).
     */
    public Currency divide(Currency val)
        throws ArithmeticException, IllegalArgumentException {
        return new Currency(super.divide(val, 2, ROUND_HALF_UP));
    }

/**
     * Returns a Currency whose value is (this / val).
     */
    public Currency divide(int val)
        throws ArithmeticException, IllegalArgumentException {
        return divide(new Currency((double)val));
    }

/**
     * Returns a Currency whose value is the absolute value of this
     * number.
     */
    public Currency absCurrency() {
        return (signum() < 0 ? negateCurrency() : this);
    }

/**
     * Returns a Currency whose value is -1 * this.
     */
    public Currency negateCurrency() {
        return new Currency(negate());
    }

/**
     * Convert to string with two decimals.
     */
    public String toString() {
        if (scale() == 2) {
            return super.toString();
        } else {
            return setScale(2, ROUND_HALF_UP).toString();
        }
    }
}

Mas não tem muito jeito se vc precisar de muuitas casas decimais e/ou mexer com double para alguma coisa...Uso sempre BigDecimal, mas custa em velocidade...
Eu também tenho problemas quando eu penso no que(que tipo Monetário ou Numérico) inserir no banco quando o assunto é dinheiro.

No caso da classe moeda blz. Todas as respostas dadas ao David se encaixam.

Mas andei relendo a matéria da Mundo Java 17 com o artigo do Phillip e pensei sobre a classe Categoria do exemplo. Ela é um Value Object (DDD, Evans), blz.

Mas pensando no banco, como persistir? Porque:

- Pensando que são categorias repetitivas (uma categoria chamada "normal" com teto "1000" e máximo de parcelas "10" como no exemplo da revista)
- E se categoria for desmembrada apenas em campos do banco da mesma tabela que possui essa categoria seguindo essa metodologia de mapeamento OR.

Então teremos um banco sem normalização.

É isso mesmo? Ou Categoria não é na verdade um Value Object?

Ou tem outro jeito de ter uma tabela para categoria e categoria não se repetir no banco e ao mesmo tempo ser Value Object?

Antes de mais nada não poste outra mensagem apenas para fazer up no seu post. O GUJ nãot em SLA e este tipo de atitude é desaconselhado pela moderação.

Você está confundindo conceitos sobre o que é um Domain Model e o que é persistência em um banco relacional. Ser um Value Object não diz como as instâncias serão persistidas (ou se serão persistidas) então a forma como você persiste os dados não influencia em algo ser um Value Object ou não.

Pelo que entendi do seu texto você pergunta se teríamos dois registros iguais na tabela. A resposta, como quase sempre, é depende do que você quer fazer, mas -novamente- não é porque você tem um value object que precisa ser assim. Nada impede que você tenha vários Value Objects absolutamente iguais em memória mas que sejam persistidos em apenas um registro no banco de dados.

A forma com que objetos são transformados em tabelas e vice-versa não influencia (teoricamente) em Domain-Driven Design.

This message was edited 3 times. Last update was at 30/10/2007 09:46:08

@BiraBoy
Existe uma thread recente sobre esse assunto da persistência dos Value Objects. (Que inclusive você chegou a postar nele)

http://www.guj.com.br/posts/list/68206.java

@Phillip
Só para esclarecer, eu concordo com você que Persistência nada tem a ver com Domain Driven Design. Porém, quando estamos aprendendo DDD e vamos implementar algum projeto pra valer, chega na hora de persistir as classes geradas com os conceitos dessa abordagem e é normal que haja uma dúvida/confusão/falta de conhecimento. Aconteceu comigo recentemente e eu aprendi o que fazer. Então, acho que apesar de serem coisas distintas, quando em um projeto real pra quem ta começando no DDD é sempre bom esclarecer.

This message was edited 1 time. Last update was at 30/10/2007 11:04:13

Primeiramente me perdoem os moderadores pela avidez

(ps: o que é SLA?)

Minha dúvida é bem específica. Voltando ao exemplo da classe Categoria do seu exemplo, Phillip.

Pensando que considero Categoria, na modelagem de domínio, um Value Object (DDD, Evans). E considerando que na minha solução específica quero que na persistência em banco ele fique numa tabela própria para que não se repita e fique assim normalizado.

Qual estratégia de mapeamento OR com hibernate se usa neste caso, nesta decisão?

Minha dúvida específica é essa.

Mais uma vez perdão

Ah emerleite é que eu quis aproveitar o tópico do David porque ele citou o exemplo da revista Mundo Java na qual surgiu minha dúvida

Você pode utilizar um id artificial que só serve como índice da tabela e para fazer relacionamentos. Ser um Value Object não indica que a classe não vá ter uma chave primária quando persistida num banco de dados relacional.

Então nesse caso, no hibernate eu deixo de mapear como component (que seria o caso da classe Moeda) e e mapeio como entidade normal, né?

No caso vai ser sua escolha.
Da uma lida no post que eu te passei que lá o Sergio explicou direitinho.

Notícias, artigos e o maior fórum brasileiro sobre Java