As far as I can tell, what you are describing can be trivially implemented with an Embeddable class and not need of AOP.

@Embeddable
class Audit {
  Timestamp created;
  String createdBy;
  String updatedBy;
}

Then you can simply add your embeddable object within your entities.

@Entity
class Order {
   @Embedded
   Audit audit;
}

Using inheritance, you might just as well make this available for a set of entities:

@MappedSuperClass
class MotherOfAllEntities {
   @Embedded
   Audit audit;
}

@Entity
class ChildClass extends MotherOfAllEntities {
}

If the information being added is just audit information, as you seem to suggest in your post you may consider using something like Hibernate Envers which seems to be an implementation of what you’re apparently suggesting with your question

@Entity
@Audited
class Order {
}

And Envers will make sure to store audit information about the entity in some other data structure.

Since Envers seem to be an implementation of something like what you want to do from scratch, you might just as well give it a look to their code and see how they did it, but yet again, if it is to implement what you described, to me it sounds like killing a fly with a bazooka.

Hibernate has events to which you can react using interceptors. Here’s an incomplete list of events:

• onDelete
• onSave
• instantiate
• afterTransactionCompletion

Take a look at org.hibernate.Interceptor to see complete list of events to which you can react using Interceptor.

Simplified example of classical usage is auditting interceptor which sets “lastmodified”:

public class AuditInterceptor extends EmptyInterceptor {
    @Override public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) throws CallbackException {
        if (entity instanceof AuditedEntity) {
            int index = findElementIndex(propertyNames, "dateModified");

            if (index >= 0) {
                state[index] = new Date();

                return true; // entity has been modified
            }
        }

        return false; // entity was not modified
    }

    private int findElementIndex(String[] propertyNames, String element) {
        for (int i = 0; i < propertyNames.length; i++) {
            if (element.equals(propertyNames[i])) {
                return i;
            }
        }

        return -1;
    }
}

Interceptors might not be enough for your needs. Luckily Hibernate’s architecture is quite pluggable – most of the functionality consists of “Services”, resp. service implementations which implement service roles (interfaces). You can override default implementations with your custom ones, or even add totally new services. But this might be more involved and might break in future versions of Hibernate. I’d recommend to stick with interceptors as much as possible.

I have quite trouble understanding what your use case is. You do not come up with a question, you come up with a solution.

Your question seems to be about metadata and where to store it.

You would now know things like:

• When a User registered
• When an item was created
• When a shopping cart was created
• When an item was added to a shopping cart
• When an order was placed
• When was the order was processed and paid

Depending on the use case it makes perfectly sense to store the metadata alongside the business data. You have to change your database scheme accordingly.

I) The simple and straightforward usecase

From that it would be natural extending a BaseItem, which has such information like created, createdby, modified, modifiedby and adding some columns to other objects like lastseen on the user.
With that you are able to derive some questions from these values:

When an item was added to a shopping cart

When you have an order and an orderposition the created of the orderposition tells you, when the entry was added.

I do not see a reason to use AOP for this usecase.

II) The more advanced usecases of Datamining and Monitoring

II a) Monitoring

Let’s suppose we have a simple ecommerce system

Let’s suppose, you have indeed an eCommerce system and not only for the sake of the example, you might be interested in monitoring like AppDynamics or New Relic or something like that.

With such a sophisticated instrumentation, you are able to monitor each and every point of your application. I can not speak for New Relic, but I have used AppDynamics for myself. With AppDynamics, you could place Information Points, where you could track everytime when a method is called – e.g. orderSubmit.

When your usecase is more of tracking the systems behaviour in case of performance improvement or simple counters, that would be a simple way to go, without touching any code.

But the main point of such systems is providing health information for your application. and I would recommend it anyways if you run an eCommerce business. Downtime is loss of money.

II b) Data Mining

In case you are interested in metadata for datamining puroses IIa is the wrong road. Depending on the scale of metadata you want to gather, you should put it to a separate datastore.

As already mentioned, there are several ways to hook into your application:

• simply edit the business code and add a simple methodcall to the external system.

Pro: It’s plain and simple. Everybody knows, what you are doing

Con: You litter your codebase

• using AOP – like you suggested

Pro: It’s a sophisticated approach to deal with such cross cutting concerns. No existing code has to be touched

Con: It makes code for inexperienced coders hard to understand – things seem to happen magically.

• Interceptors as already mentioned

Is something in between.

For simplicity and readability, I would go for the first solution despite the fact, that you have another kind of “logging”

P.S.: Nothing hinders you from doing I) and II) alltogether :]

Dont invent the wheel again!

Hibernate has Plug-ins, use them! You may be interrested in Enver and Auditing.

This is a example of what you are looking for:

AuditReader reader = AuditReaderFactory.get(entityManager);

Person person2_rev1 = reader.find(Person.class, person2.getId(), 1); 
                            // version 1 is from archive
assert person2_rev1.getAddress().equals(new Address("Grimmauld Place", 12));

Address address1_rev1 = reader.find(Address.class, address1.getId(), 1);
assert address1_rev1.getPersons().getSize() == 1;