Metadados para Melhor Expressar Relacionamento entre Objetos: Que tal?

Acho que nunca li nada sobre isso, se alguem possuir bibliografia, por favor compartilhe.

Todo mundo que ja estudou um pouquinho de OOP sabe que existem diversos tipos catalogados de relacionamento entre objetos, mas vou focar tres: Agregaçao, Composiçao e Associaçao (Aggregation, Composition e Association).

E impossivel (pelo menso que eu saiba) definir um relacionamento destes declarativamente em Java < 5. Quando voce faz:

Nao da para imaginar que tipo de relaçao A e B tem, voce vai rpecisar olhar o codigo. Geralmente compostos vao ser instanciados (ou pegos de algum lugar de forem Value Objects ou coisa parecida) diretamente na classe (na declaraçao do atributo ou no cosntrutor dessa), associaçoes geralmente sao setadas.

Com o uso de annotations, daria para amrcar essas relaçoes, definindo o que eh de qual tipo. O que voces acham disso?

Em primeira instancia, coisas como persistencia poderiam ser facilitadas (quando um objeto e atualizado, seus agregados tambem devem ser, mas nao seus associados), e outros usos podem surgir.

Alguma opiniao?

Assim, metade do trabalho feito com XML estaria resolvido trabalhando desse modo, mas seria ótimo se houvesse uma padronização nisso. Tipo, um annotation que simbolize composição, outro agregação, pra num ficar todo mundo inventando.

Será que dá pra abrir um request só pra colocar isso no Java?

Metade da configuração do Spring tava resolvida

Tipo, agora veio mais uma coisa, quem ia fazer isso? Mais um framework IoC? Aspectos? Mágica?

Isso o que exatamente?

O programador eh quem conhece o relacionamentod e suas classes. Os frameworks podem usar essa ifnroamçao adicional para prover algumas simplificaçoes, outros programadores podem se beneficiar das anotaçoes como documentaçao (ja que voce vai acabar precisando dum diagrama para msotrar suas agregaçoes se nao usar algo do tipo)...

Baixei a JSR 250 (da qual o michael Santos faz parte, voce ta por ai, mister m?) e vi que o trabalho esta bem no inicio, ams nao contempla nada perto diso 9apesar de eu ter adorado algumas como @generated

).

Acabo de escrever um email pro time da spec:

Hi everyone,

I just downloaded the current draft for "JSR 250 - Common Annotations
for The Java Platform" and noticed that one of the things I believe
could really be great with annotations was missing.

As far as I know, there is no way to represent in Java or in any
language I've programmed so far that a relationship between two or
more objects is an aggregation, association or composition (ok, some
languages such as C++ provides a reference/value mechanism that makes
this no that hard, but it's still not the point).

Seems like some tools (e.g.
http://www.modelistic.com/website/userGuide/diagrams/Associations.html
) mark these relationships using doclets. Using this, some tool can
discover association roles given source files. As we all know much was
done through doclets and annotations are here to bring all this
information to runtime, when needed.

I think that this information can be really useful as documentation
for the code, and can really help EJB3/Hibernate, IoC containers,
Application Servers and other tools handling user objects' lifecycle.

It will be known that when an object is removed from a cache, updated,
deleted, created or something, all its relationships should be
evaluated, maybe deleting some compositions or doing some related
stuff.

This said, I suggest that you include in the specification annotations
for classic (and UML/OMG specified) object relationships between
objects (Aggregation, Association and Composition at least).

Just as I believe annotations can be great to bring UML stereotypes to
the real world, I believe people (and specially CASE tools) will use
an approach like this to document these relationships. I believe that
the objective of this JSR is to provide standard annotations, so it
would be no good if we have each vendor creating its own set of
annotations to document relationships.

Thanks for your time and regards,

--
Phillip Calçado
http://www.fragmental.com.br
ICQ: 1110nine38six5
M$N: pcalcado@gmail.com
Y!: pcalcado@yahoo.com
Crux Sacra Sit Mihi Lux

*aplausos*

Forum Spammer Membro desde: 11/02/2005 08:08:02 Mensagens: 1411 Offline

shoes wrote:voce ta por ai, mister m?

Num sei pq, mas eu imaginei a vós do Cid Moreira chamando o Mister M!

Thread.start() Membro desde: 21/03/2005 19:13:04 Mensagens: 26 Offline

Eu sei que já MUITO tempo que isso foi postado, mas vou responder mesmo assim...

Conversando com um amigo sobre esse post ele me lembrou que essa idéia já existe nos doclets, por exemplo a ferramenta OMONDO, ao gerar as classes, coloca esse tipo de configuração pra controle dela em forma de doclet.

No caso, essas configurações virariam essas annotations!

Valeu!

Romulinho wrote:Eu sei que já MUITO tempo que isso foi postado, mas vou responder mesmo assim...

Conversando com um amigo sobre esse post ele me lembrou que essa idéia já existe nos doclets, por exemplo a ferramenta OMONDO, ao gerar as classes, coloca esse tipo de configuração pra controle dela em forma de doclet.

No caso, essas configurações virariam essas annotations!

Valeu!

Muito tempo mesmo. Inclusive nesta época eu usava xdoclet

A idéia expressa aqui é para er anotações semânticas no código em si, não apenas nos comentários como faz xdoclet. Pre-processamento é útil mas a idéia é meta-programação em real time com semântica OO. Eu eu ainda não vi nada muito parecido em 4 anos.

Pessoal,

alguém sabe me dizer se existe algum framework, library ou extensão (com pré-compilador) do Java que permita construir relacionamentos (associações) N-N entre objetos sem usar atributos de objetos?

Pergunto isto porque sempre que necessita-se fazer um relacionamento Many-To-Many, entre as classes A e B, o código fonte acaba necessitando usar algum Collection (List, Set, etc) para guardar as referências de objetos de uma classe na outra. Sendo assim, métodos add, remove, get(), entre outros, acabam surgindo afim de que o objeto proprietário da coleção possa dar acesso público e controlado, a mesma.

Eu sei que tem ferramentas que fazem boa parte deste trabalho de geração de código, mas a questão toda é que olhando para o código, você não encherga um relacionamento, mas sim um atributo. A implementação dos métodos de acesso à coleção acabam se misturando ao "código original" da classe.

Outro problema condiz a mudança de cardinalidade. Se por acaso for necessário trocar de Many-To-Many para, por exemplo, Many-To-One, o atributo que aponta para objetos da classe que mudou a cardinalidade deverá mudar de Collection para um simples atributo (de único valor).

Não sei se consegui ser claro, mas o que eu quero saber é se existe, em Java, alguma forma de eu declarar relacionamentos assim como eu declaro atributos e métodos de uma classe?

Quando eu falo em "declarar relacionamentos", significa duas coisas:
1. que toda a funcionalidade de adicionar, remover e recuperar os objetos, já esteja "implícita" na declaração, sem necessidade de "código extra" para se fazer isto.
2. que fique explícito que ali está se declarando um relacionamento entre objetos, não um atributo de objeto.

bom... acho que era isso.

Grande abraço a todos
e muito obrigado.

Concordo que seria legal. *aplausos* ^2

Oras... e o que dizer de associações qualificadas, navegabilidade, certas multiplicidades, classes de associação, associações ternárias, associações condicionais e etc?

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