Skip to main content

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [List Home]
RE: [aspectj-users] Inter-type declaration of constructor usingannotations

Hi Johno,

There are a number of code generation capabilities that AspectJ doesn't
provide, and this is a good example of one that would be useful but AspectJ
doesn't support. In AspectJ 1.0 you actually could write an ITD like you
wrote for #1 (e.g., public Persistable+.new(..)), but the AspectJ 1.1+
restriction on writing ITD's to only simple types resulting in losing that
ability. It would nice if the restriction of ITD's to work only on a simple
type could be relaxed (using the least common denominator type for type
patterns). But failing having an enhancement like that...

One approach that you often see in O/R frameworks is requiring a no-op
constructor on the persistable classes. If you follow that approach, you
could instead use an ITD to define a method void Persistable.init(Transfer)
that runs after construction.  I'd make my persistent classes implement an
interface Persistable rather than a superclass (it's not good to require
them to all have a common superclass, of course).

But if you really want to avoid adding another constructor to all the
classes, it is possible to use a somewhat ugly work-around. You could define
a common factory method to create persistent objects (e.g., Article article
= Persistence.create(Article.class);) that uses reflection to invoke a
normal constructor of the domain object, but use around advice to
short-circuit the normal constructor behavior, then delegate on to a method
like Persistable.init(Transfer). Given that this code will be encapsulated
inside your persistence engine, it might be reasonable to do this (as long
as you are weaving into any persisted class).

HTH,
Ron

-----Original Message-----
From: aspectj-users-bounces@xxxxxxxxxxx
[mailto:aspectj-users-bounces@xxxxxxxxxxx] On Behalf Of Johno
Sent: Sunday, November 12, 2006 3:54 AM
To: aspectj-users@xxxxxxxxxxx
Subject: [aspectj-users] Inter-type declaration of constructor
usingannotations

Hi,

I'm currently working on a object-relational mapper using annotations.
Here is a simple example of a persistable class.

@Persistent
public class Article {
    private Person author;

    public Article(Person anAuthor) {
        author = anAuthor;
    }
}

The main problem is that there are two kinds of object construction in
context of OR mapping. Creating a new object that will be inserted into
DB and loading an object from DB. So you need two constructors for a
persistable class.

@Persistent
public class Article {
    private Person author;

    public Article(Transfer transfer) {
        // load data from transfer to entities
    }

    public Article(Person anAuthor) {
        author = anAuthor;
    }
}

I would like to introduce this new "transfer" constructor using
inter-type declarations. Is it possible? I have tried various things:

1)  There is no way to use
public (@Persistent *).new(Transfer transfer) {...}

2) If I create a PersistentRoot class with transfer constructor and use
declare parents : @Perstistent * extends PersistentRoot;

then I cannot use this constructor when creating subclasses. new 
Article(Transfer transfer); is not usable.

3) With mentioned PersistentRoot I must add constructor to every 
persistent class by hand.

public Article.new(Transfer transfer) { super(transfer); }

Which is the only working way I have found, but its really ugly hack.

I am new to AspectJ so probably I am missing something. Any ideas?

_______________________________________________
aspectj-users mailing list
aspectj-users@xxxxxxxxxxx
https://dev.eclipse.org/mailman/listinfo/aspectj-users



Back to the top